Systolic arithmetic on sparse data

ABSTRACT

Embodiments described herein provided for an instruction and associated logic to enable a processing resource including a tensor accelerator to perform optimized computation of sparse submatrix operations. One embodiment provides hardware logic to apply a numerical transform to matrix data to increase the sparsity of the data. Increasing the sparsity may result in a higher compression ratio when the matrix data is compressed.

CROSS-REFERENCE

This application claims priority to U.S. Provisional Patent ApplicationNo. 62/935,670 filed Nov. 15, 2019, which is hereby incorporated hereinby reference.

FIELD

This disclosure relates generally to data processing and moreparticularly to data processing via a general-purpose graphicsprocessing unit.

BACKGROUND OF THE DISCLOSURE

Current parallel graphics data processing includes systems and methodsdeveloped to perform specific operations on graphics data such as, forexample, linear interpolation, tessellation, rasterization, texturemapping, depth testing, etc. Traditionally, graphics processors usedfixed function computational units to process graphics data. However,more recently, portions of graphics processors have been madeprogrammable, enabling such processors to support a wider variety ofoperations for processing vertex and fragment data.

To further increase performance, graphics processors typically implementprocessing techniques such as pipelining that attempt to process, inparallel, as much graphics data as possible throughout the differentparts of the graphics pipeline. Parallel graphics processors with singleinstruction, multiple thread (SIMT) architectures are designed tomaximize the amount of parallel processing in the graphics pipeline. Ina SIMT architecture, groups of parallel threads attempt to executeprogram instructions synchronously together as often as possible toincrease processing efficiency. A general overview of software andhardware for SIMI′ architectures can be found in Shane Cook, CUDAProgramming Chapter 3, pages 37-51 (2013).

BRIEF DESCRIPTION OF THE DRAWINGS

So that the manner in which the above recited features of the presentembodiments can be understood in detail, a more particular descriptionof the embodiments, briefly summarized above, may be had by reference toembodiments, some of which are illustrated in the appended drawings. Itis to be noted, however, that the appended drawings illustrate onlytypical embodiments and are therefore not to be considered limiting ofits scope.

FIG. 1 is a block diagram illustrating a computer system configured toimplement one or more aspects of the embodiments described herein;

FIG. 2A-2D illustrate parallel processor components;

FIG. 3A-3C are block diagrams of graphics multiprocessors andmultiprocessor-based GPUs;

FIG. 4A-4F illustrate an exemplary architecture in which a plurality ofGPUs is communicatively coupled to a plurality of multi-core processors;

FIG. 5 illustrates a graphics processing pipeline;

FIG. 6 illustrates a machine learning software stack;

FIG. 7 illustrates a general-purpose graphics processing unit;

FIG. 8 illustrates a multi-GPU computing system;

FIG. 9A-9B illustrate layers of exemplary deep neural networks;

FIG. 10 illustrates an exemplary recurrent neural network;

FIG. 11 illustrates training and deployment of a deep neural network;

FIG. 12A is a block diagram illustrating distributed learning;

FIG. 12B is a block diagram illustrating a programmable networkinterface to accelerate distributed learning;

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC)suitable for performing inferencing using a trained model;

FIG. 14 is a block diagram of a processing system;

FIG. 15A-15C illustrate computing systems and graphics processors;

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures;

FIG. 17 is a block diagram of a graphics processing engine of a graphicsprocessor;

FIG. 18A-18B illustrate thread execution logic including an array ofprocessing elements employed in a graphics processor core;

FIG. 19 illustrates an additional execution unit;

FIG. 20 is a block diagram illustrating a graphics processor instructionformats;

FIG. 21 is a block diagram of an additional graphics processorarchitecture;

FIG. 22A-22B illustrate a graphics processor command format and commandsequence;

FIG. 23 illustrates exemplary graphics software architecture for a dataprocessing system;

FIG. 24A is a block diagram illustrating an IP core development system;

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly;

FIG. 24C illustrates a package assembly that includes multiple units ofhardware logic chiplets connected to a substrate (e.g., base die);

FIG. 24D illustrates a package assembly including interchangeablechiplets;

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit;

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC;

FIG. 27 illustrates an additional execution unit, according to anembodiment;

FIG. 28 illustrates a matrix operation performed by an instructionpipeline, according to an embodiment;

FIG. 29A-29B illustrate details of hardware-based systolic tensor array,according to some embodiments;

FIG. 30 illustrates a processing resource including a systolic tensorarray with sparse optimizations, according to an embodiment;

FIG. 31A-31B illustrates a system to bypass zero value submatrices,according to embodiments;

FIG. 32 illustrates a compute resource including logic to bypass thesystolic tensor array for operations on a submatrix that include asingle non-zero value;

FIG. 33 illustrates a compute architecture configured to enablecompressed transmission of neural network data, according to anembodiment;

FIG. 34A-34B illustrates significance map encoding for sparse neuralnetwork data, according to embodiments;

FIG. 35 illustrates the use of significance map data to facilitate thebypassing or clock/power gating of elements of a systolic tensor array;

FIG. 36 illustrates a system to transform sparse neural network data tocompact non-zero coefficients, according to an embodiment;

FIG. 37A-37B illustrates logic units to perform transformations andinverse transformations on sparse neural network data;

FIG. 38A-38B illustrate methods of generating and using transformedmatrices on a graphics processor;

FIG. 39 illustrates a version of the systolic tensor array that isconfigured to operate on compressed or encoded data; and

FIG. 40 illustrates a method of performing systolic arithmetic oncompressed or encoded data; and

FIG. 41 is a block diagram of a computing device including a graphicsprocessor, according to an embodiment.

DETAILED DESCRIPTION

A graphics processing unit (GPU) is communicatively coupled tohost/processor cores to accelerate, for example, graphics operations,machine-learning operations, pattern analysis operations, and/or variousgeneral-purpose GPU (GPGPU) functions. The GPU may be communicativelycoupled to the host processor/cores over a bus or another interconnect(e.g., a high-speed interconnect such as PCIe or NVLink). Alternatively,the GPU may be integrated on the same package or chip as the cores andcommunicatively coupled to the cores over an internal processorbus/interconnect (i.e., internal to the package or chip). Regardless ofthe manner in which the GPU is connected, the processor cores mayallocate work to the GPU in the form of sequences ofcommands/instructions contained in a work descriptor. The GPU then usesdedicated circuitry/logic for efficiently processing thesecommands/instructions.

In the following description, numerous specific details are set forth toprovide a more thorough understanding. However, it will be apparent toone of skill in the art that the embodiments described herein may bepracticed without one or more of these specific details. In otherinstances, well-known features have not been described to avoidobscuring the details of the present embodiments.

System Overview

FIG. 1 is a block diagram illustrating a computing system 100 configuredto implement one or more aspects of the embodiments described herein.The computing system 100 includes a processing subsystem 101 having oneor more processor(s) 102 and a system memory 104 communicating via aninterconnection path that may include a memory hub 105. The memory hub105 may be a separate component within a chipset component or may beintegrated within the one or more processor(s) 102. The memory hub 105couples with an I/O subsystem 111 via a communication link 106. The I/Osubsystem 111 includes an I/O hub 107 that can enable the computingsystem 100 to receive input from one or more input device(s) 108.Additionally, the I/O hub 107 can enable a display controller, which maybe included in the one or more processor(s) 102, to provide outputs toone or more display device(s) 110A. In one embodiment the one or moredisplay device(s) 110A coupled with the I/O hub 107 can include a local,internal, or embedded display device.

The processing subsystem 101, for example, includes one or more parallelprocessor(s) 112 coupled to memory hub 105 via a bus or othercommunication link 113. The communication link 113 may be one of anynumber of standards-based communication link technologies or protocols,such as, but not limited to PCI Express, or may be a vendor specificcommunications interface or communications fabric. The one or moreparallel processor(s) 112 may form a computationally focused parallel orvector processing system that can include a large number of processingcores and/or processing clusters, such as a many integrated core (MIC)processor. For example, the one or more parallel processor(s) 112 form agraphics processing subsystem that can output pixels to one of the oneor more display device(s) 110A coupled via the I/O Hub 107. The one ormore parallel processor(s) 112 can also include a display controller anddisplay interface (not shown) to enable a direct connection to one ormore display device(s) 110B.

Within the I/O subsystem 111, a system storage unit 114 can connect tothe I/O hub 107 to provide a storage mechanism for the computing system100. An I/O switch 116 can be used to provide an interface mechanism toenable connections between the I/O hub 107 and other components, such asa network adapter 118 and/or wireless network adapter 119 that may beintegrated into the platform, and various other devices that can beadded via one or more add-in device(s) 120. The add-in device(s) 120 mayalso include, for example, one or more external graphics processordevices, graphics cards, and/or compute accelerators. The networkadapter 118 can be an Ethernet adapter or another wired network adapter.The wireless network adapter 119 can include one or more of a Wi-Fi,Bluetooth, near field communication (NFC), or other network device thatincludes one or more wireless radios.

The computing system 100 can include other components not explicitlyshown, including USB or other port connections, optical storage drives,video capture devices, and the like, which may also be connected to theI/O hub 107. Communication paths interconnecting the various componentsin FIG. 1 may be implemented using any suitable protocols, such as PCI(Peripheral Component Interconnect) based protocols (e.g., PCI-Express),or any other bus or point-to-point communication interfaces and/orprotocol(s), such as the NVLink high-speed interconnect, Compute ExpressLink™ (CXL™) (e.g., CXL.mem), Infinity Fabric (IF), Ethernet (IEEE802.3), remote direct memory access (RDMA), InfiniBand, Internet WideArea RDMA Protocol (iWARP), Transmission Control Protocol (TCP), UserDatagram Protocol (UDP), quick UDP Internet Connections (QUIC), RDMAover Converged Ethernet (RoCE), Intel QuickPath Interconnect (QPI),Intel Ultra Path Interconnect (UPI), Intel On-Chip System Fabric (IOSF),Omnipath, HyperTransport, Advanced Microcontroller Bus Architecture(AMBA) interconnect, OpenCAPI, Gen-Z, Cache Coherent Interconnect forAccelerators (CCIX), 3GPP Long Term Evolution (LTE) (4G), 3GPP 5G, andvariations thereof, or wired or wireless interconnect protocols known inthe art. In some examples, data can be copied or stored to virtualizedstorage nodes using a protocol such as non-volatile memory express(NVMe) over Fabrics (NVMe-oF) or NVMe.

The one or more parallel processor(s) 112 may incorporate circuitryoptimized for graphics and video processing, including, for example,video output circuitry, and constitutes a graphics processing unit(GPU). Alternatively or additionally, the one or more parallelprocessor(s) 112 can incorporate circuitry optimized for general purposeprocessing, while preserving the underlying computational architecture,described in greater detail herein. Components of the computing system100 may be integrated with one or more other system elements on a singleintegrated circuit. For example, the one or more parallel processor(s)112, memory hub 105, processor(s) 102, and I/O hub 107 can be integratedinto a system on chip (SoC) integrated circuit. Alternatively, thecomponents of the computing system 100 can be integrated into a singlepackage to form a system in package (SIP) configuration. In oneembodiment at least a portion of the components of the computing system100 can be integrated into a multi-chip module (MCM), which can beinterconnected with other multi-chip modules into a modular computingsystem.

It will be appreciated that the computing system 100 shown herein isillustrative and that variations and modifications are possible. Theconnection topology, including the number and arrangement of bridges,the number of processor(s) 102, and the number of parallel processor(s)112, may be modified as desired. For instance, system memory 104 can beconnected to the processor(s) 102 directly rather than through a bridge,while other devices communicate with system memory 104 via the memoryhub 105 and the processor(s) 102. In other alternative topologies, theparallel processor(s) 112 are connected to the I/O hub 107 or directlyto one of the one or more processor(s) 102, rather than to the memoryhub 105. In other embodiments, the I/O hub 107 and memory hub 105 may beintegrated into a single chip. It is also possible that two or more setsof processor(s) 102 are attached via multiple sockets, which can couplewith two or more instances of the parallel processor(s) 112.

Some of the particular components shown herein are optional and may notbe included in all implementations of the computing system 100. Forexample, any number of add-in cards or peripherals may be supported, orsome components may be eliminated. Furthermore, some architectures mayuse different terminology for components similar to those illustrated inFIG. 1. For example, the memory hub 105 may be referred to as aNorthbridge in some architectures, while the I/O hub 107 may be referredto as a Southbridge.

FIG. 2A illustrates a parallel processor 200. The parallel processor 200may be a GPU, GPGPU or the like as described herein. The variouscomponents of the parallel processor 200 may be implemented using one ormore integrated circuit devices, such as programmable processors,application specific integrated circuits (ASICs), or field programmablegate arrays (FPGA). The illustrated parallel processor 200 may be one ormore of the parallel processor(s) 112 shown in FIG. 1.

The parallel processor 200 includes a parallel processing unit 202. Theparallel processing unit includes an I/O unit 204 that enablescommunication with other devices, including other instances of theparallel processing unit 202. The I/O unit 204 may be directly connectedto other devices. For instance, the I/O unit 204 connects with otherdevices via the use of a hub or switch interface, such as memory hub105. The connections between the memory hub 105 and the I/O unit 204form a communication link 113. Within the parallel processing unit 202,the I/O unit 204 connects with a host interface 206 and a memorycrossbar 216, where the host interface 206 receives commands directed toperforming processing operations and the memory crossbar 216 receivescommands directed to performing memory operations.

When the host interface 206 receives a command buffer via the I/O unit204, the host interface 206 can direct work operations to perform thosecommands to a front end 208. In one embodiment the front end 208 coupleswith a scheduler 210, which is configured to distribute commands orother work items to a processing cluster array 212. The scheduler 210ensures that the processing cluster array 212 is properly configured andin a valid state before tasks are distributed to the processing clustersof the processing cluster array 212. The scheduler 210 may beimplemented via firmware logic executing on a microcontroller. Themicrocontroller implemented scheduler 210 is configurable to performcomplex scheduling and work distribution operations at coarse and finegranularity, enabling rapid preemption and context switching of threadsexecuting on the processing cluster array 212. Preferably, the hostsoftware can prove workloads for scheduling on the processing clusterarray 212 via one of multiple graphics processing doorbells. In otherexamples, polling for new workloads or interrupts can be used toidentify or indicate availability of work to perform. The workloads canthen be automatically distributed across the processing cluster array212 by the scheduler 210 logic within the scheduler microcontroller.

The processing cluster array 212 can include up to “N” processingclusters (e.g., cluster 214A, cluster 214B, through cluster 214N). Eachcluster 214A-214N of the processing cluster array 212 can execute alarge number of concurrent threads. The scheduler 210 can allocate workto the clusters 214A-214N of the processing cluster array 212 usingvarious scheduling and/or work distribution algorithms, which may varydepending on the workload arising for each type of program orcomputation. The scheduling can be handled dynamically by the scheduler210, or can be assisted in part by compiler logic during compilation ofprogram logic configured for execution by the processing cluster array212. Optionally, different clusters 214A-214N of the processing clusterarray 212 can be allocated for processing different types of programs orfor performing different types of computations.

The processing cluster array 212 can be configured to perform varioustypes of parallel processing operations. For example, the processingcluster array 212 is configured to perform general-purpose parallelcompute operations. For example, the processing cluster array 212 caninclude logic to execute processing tasks including filtering of videoand/or audio data, performing modeling operations, including physicsoperations, and performing data transformations.

The processing cluster array 212 is configured to perform parallelgraphics processing operations. In such embodiments in which theparallel processor 200 is configured to perform graphics processingoperations, the processing cluster array 212 can include additionallogic to support the execution of such graphics processing operations,including, but not limited to texture sampling logic to perform textureoperations, as well as tessellation logic and other vertex processinglogic. Additionally, the processing cluster array 212 can be configuredto execute graphics processing related shader programs such as, but notlimited to vertex shaders, tessellation shaders, geometry shaders, andpixel shaders. The parallel processing unit 202 can transfer data fromsystem memory via the I/O unit 204 for processing. During processing thetransferred data can be stored to on-chip memory (e.g., parallelprocessor memory 222) during processing, then written back to systemmemory.

In embodiments in which the parallel processing unit 202 is used toperform graphics processing, the scheduler 210 may be configured todivide the processing workload into approximately equal sized tasks, tobetter enable distribution of the graphics processing operations tomultiple clusters 214A-214N of the processing cluster array 212. In someof these embodiments, portions of the processing cluster array 212 canbe configured to perform different types of processing. For example afirst portion may be configured to perform vertex shading and topologygeneration, a second portion may be configured to perform tessellationand geometry shading, and a third portion may be configured to performpixel shading or other screen space operations, to produce a renderedimage for display. Intermediate data produced by one or more of theclusters 214A-214N may be stored in buffers to allow the intermediatedata to be transmitted between clusters 214A-214N for furtherprocessing.

During operation, the processing cluster array 212 can receiveprocessing tasks to be executed via the scheduler 210, which receivescommands defining processing tasks from front end 208. For graphicsprocessing operations, processing tasks can include indices of data tobe processed, e.g., surface (patch) data, primitive data, vertex data,and/or pixel data, as well as state parameters and commands defining howthe data is to be processed (e.g., what program is to be executed). Thescheduler 210 may be configured to fetch the indices corresponding tothe tasks or may receive the indices from the front end 208. The frontend 208 can be configured to ensure the processing cluster array 212 isconfigured to a valid state before the workload specified by incomingcommand buffers (e.g., batch-buffers, push buffers, etc.) is initiated.

Each of the one or more instances of the parallel processing unit 202can couple with parallel processor memory 222. The parallel processormemory 222 can be accessed via the memory crossbar 216, which canreceive memory requests from the processing cluster array 212 as well asthe I/O unit 204. The memory crossbar 216 can access the parallelprocessor memory 222 via a memory interface 218. The memory interface218 can include multiple partition units (e.g., partition unit 220A,partition unit 220B, through partition unit 220N) that can each coupleto a portion (e.g., memory unit) of parallel processor memory 222. Thenumber of partition units 220A-220N may be configured to be equal to thenumber of memory units, such that a first partition unit 220A has acorresponding first memory unit 224A, a second partition unit 220B has acorresponding second memory unit 224B, and an Nth partition unit 220Nhas a corresponding Nth memory unit 224N. In other embodiments, thenumber of partition units 220A-220N may not be equal to the number ofmemory devices.

The memory units 224A-224N can include various types of memory devices,including dynamic random-access memory (DRAM) or graphics random accessmemory, such as synchronous graphics random access memory (SGRAM),including graphics double data rate (GDDR) memory. Optionally, thememory units 224A-224N may also include 3D stacked memory, including butnot limited to high bandwidth memory (HBM). Persons skilled in the artwill appreciate that the specific implementation of the memory units224A-224N can vary, and can be selected from one of various conventionaldesigns. Render targets, such as frame buffers or texture maps may bestored across the memory units 224A-224N, allowing partition units220A-220N to write portions of each render target in parallel toefficiently use the available bandwidth of parallel processor memory222. In some embodiments, a local instance of the parallel processormemory 222 may be excluded in favor of a unified memory design thatutilizes system memory in conjunction with local cache memory.

Optionally, any one of the clusters 214A-214N of the processing clusterarray 212 has the ability to process data that will be written to any ofthe memory units 224A-224N within parallel processor memory 222. Thememory crossbar 216 can be configured to transfer the output of eachcluster 214A-214N to any partition unit 220A-220N or to another cluster214A-214N, which can perform additional processing operations on theoutput. Each cluster 214A-214N can communicate with the memory interface218 through the memory crossbar 216 to read from or write to variousexternal memory devices. In one of the embodiments with the memorycrossbar 216 the memory crossbar 216 has a connection to the memoryinterface 218 to communicate with the I/O unit 204, as well as aconnection to a local instance of the parallel processor memory 222,enabling the processing units within the different processing clusters214A-214N to communicate with system memory or other memory that is notlocal to the parallel processing unit 202. Generally, the memorycrossbar 216 may, for example, be able to use virtual channels toseparate traffic streams between the clusters 214A-214N and thepartition units 220A-220N.

While a single instance of the parallel processing unit 202 isillustrated within the parallel processor 200, any number of instancesof the parallel processing unit 202 can be included. For example,multiple instances of the parallel processing unit 202 can be providedon a single add-in card, or multiple add-in cards can be interconnected.For example, the parallel processor 200 can be an add-in device, such asadd-in device 120 of FIG. 1, which may be a graphics card such as adiscrete graphics card that includes one or more GPUs, one or morememory devices, and device-to-device or network or fabric interfaces.The different instances of the parallel processing unit 202 can beconfigured to inter-operate even if the different instances havedifferent numbers of processing cores, different amounts of localparallel processor memory, and/or other configuration differences.Optionally, some instances of the parallel processing unit 202 caninclude higher precision floating point units relative to otherinstances. Systems incorporating one or more instances of the parallelprocessing unit 202 or the parallel processor 200 can be implemented ina variety of configurations and form factors, including but not limitedto desktop, laptop, or handheld personal computers, servers,workstations, game consoles, and/or embedded systems. An orchestratorcan form composite nodes for workload performance using one or more of:disaggregated processor resources, cache resources, memory resources,storage resources, and networking resources.

FIG. 2B is a block diagram of a partition unit 220. The partition unit220 may be an instance of one of the partition units 220A-220N of FIG.2A. As illustrated, the partition unit 220 includes an L2 cache 221, aframe buffer interface 225, and a ROP 226 (raster operations unit). TheL2 cache 221 is a read/write cache that is configured to perform loadand store operations received from the memory crossbar 216 and ROP 226.Read misses and urgent write-back requests are output by L2 cache 221 toframe buffer interface 225 for processing. Updates can also be sent tothe frame buffer via the frame buffer interface 225 for processing. Inone embodiment the frame buffer interface 225 interfaces with one of thememory units in parallel processor memory, such as the memory units224A-224N of FIG. 2A (e.g., within parallel processor memory 222). Thepartition unit 220 may additionally or alternatively also interface withone of the memory units in parallel processor memory via a memorycontroller (not shown).

In graphics applications, the ROP 226 is a processing unit that performsraster operations such as stencil, z test, blending, and the like. TheROP 226 then outputs processed graphics data that is stored in graphicsmemory. In some embodiments the ROP 226 includes or couples with a CODEC227 that includes compression logic to compress depth or color data thatis written to memory or the L2 cache 221 and decompress depth or colordata that is read from memory or the L2 cache 221. The compression logiccan be lossless compression logic that makes use of one or more ofmultiple compression algorithms. The type of compression that isperformed by the CODEC 227 can vary based on the statisticalcharacteristics of the data to be compressed. For example, in oneembodiment, delta color compression is performed on depth and color dataon a per-tile basis. In one embodiment the CODEC 227 includescompression and decompression logic that can compress and decompresscompute data associated with machine learning operations. The CODEC 227can, for example, compress sparse matrix data for sparse machinelearning operations. The CODEC 227 can also compress sparse matrix datathat is encoded in a sparse matrix format (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.) to generate compressed and encoded sparse matrix data. Thecompressed and encoded sparse matrix data can be decompressed and/ordecoded before being processed by processing elements or the processingelements can be configured to consume compressed, encoded, or compressedand encoded data for processing.

The ROP 226 may be included within each processing cluster (e.g.,cluster 214A-214N of FIG. 2A) instead of within the partition unit 220.In such embodiment, read and write requests for pixel data aretransmitted over the memory crossbar 216 instead of pixel fragment data.The processed graphics data may be displayed on a display device, suchas one of the one or more display device(s) 110 of FIG. 1, routed forfurther processing by the processor(s) 102, or routed for furtherprocessing by one of the processing entities within the parallelprocessor 200 of FIG. 2A.

FIG. 2C is a block diagram of a processing cluster 214 within a parallelprocessing unit. For example, the processing cluster is an instance ofone of the processing clusters 214A-214N of FIG. 2A. The processingcluster 214 can be configured to execute many threads in parallel, wherethe term “thread” refers to an instance of a particular programexecuting on a particular set of input data. Optionally,single-instruction, multiple-data (SIMD) instruction issue techniquesmay be used to support parallel execution of a large number of threadswithout providing multiple independent instruction units. Alternatively,single-instruction, multiple-thread (SIMT) techniques may be used tosupport parallel execution of a large number of generally synchronizedthreads, using a common instruction unit configured to issueinstructions to a set of processing engines within each one of theprocessing clusters. Unlike a SIMD execution regime, where allprocessing engines typically execute identical instructions, SIMTexecution allows different threads to more readily follow divergentexecution paths through a given thread program. Persons skilled in theart will understand that a SIMD processing regime represents afunctional subset of a SIMT processing regime.

Operation of the processing cluster 214 can be controlled via a pipelinemanager 232 that distributes processing tasks to SIMT parallelprocessors. The pipeline manager 232 receives instructions from thescheduler 210 of FIG. 2A and manages execution of those instructions viaa graphics multiprocessor 234 and/or a texture unit 236. The illustratedgraphics multiprocessor 234 is an exemplary instance of a SIMT parallelprocessor. However, various types of SIMT parallel processors ofdiffering architectures may be included within the processing cluster214. One or more instances of the graphics multiprocessor 234 can beincluded within a processing cluster 214. The graphics multiprocessor234 can process data and a data crossbar 240 can be used to distributethe processed data to one of multiple possible destinations, includingother shader units. The pipeline manager 232 can facilitate thedistribution of processed data by specifying destinations for processeddata to be distributed via the data crossbar 240.

Each graphics multiprocessor 234 within the processing cluster 214 caninclude an identical set of functional execution logic (e.g., arithmeticlogic units, load-store units, etc.). The functional execution logic canbe configured in a pipelined manner in which new instructions can beissued before previous instructions are complete. The functionalexecution logic supports a variety of operations including integer andfloating-point arithmetic, comparison operations, Boolean operations,bit-shifting, and computation of various algebraic functions. The samefunctional-unit hardware could be leveraged to perform differentoperations and any combination of functional units may be present.

The instructions transmitted to the processing cluster 214 constitute athread. A set of threads executing across the set of parallel processingengines is a thread group. A thread group executes the same program ondifferent input data. Each thread within a thread group can be assignedto a different processing engine within a graphics multiprocessor 234. Athread group may include fewer threads than the number of processingengines within the graphics multiprocessor 234. When a thread groupincludes fewer threads than the number of processing engines, one ormore of the processing engines may be idle during cycles in which thatthread group is being processed. A thread group may also include morethreads than the number of processing engines within the graphicsmultiprocessor 234. When the thread group includes more threads than thenumber of processing engines within the graphics multiprocessor 234,processing can be performed over consecutive clock cycles. Optionally,multiple thread groups can be executed concurrently on the graphicsmultiprocessor 234.

The graphics multiprocessor 234 may include an internal cache memory toperform load and store operations. Optionally, the graphicsmultiprocessor 234 can forego an internal cache and use a cache memory(e.g., level 1 (L1) cache 248) within the processing cluster 214. Eachgraphics multiprocessor 234 also has access to level 2 (L2) cacheswithin the partition units (e.g., partition units 220A-220N of FIG. 2A)that are shared among all processing clusters 214 and may be used totransfer data between threads. The graphics multiprocessor 234 may alsoaccess off-chip global memory, which can include one or more of localparallel processor memory and/or system memory. Any memory external tothe parallel processing unit 202 may be used as global memory.Embodiments in which the processing cluster 214 includes multipleinstances of the graphics multiprocessor 234 can share commoninstructions and data, which may be stored in the L1 cache 248.

Each processing cluster 214 may include an MMU 245 (memory managementunit) that is configured to map virtual addresses into physicaladdresses. In other embodiments, one or more instances of the MMU 245may reside within the memory interface 218 of FIG. 2A. The MMU 245includes a set of page table entries (PTEs) used to map a virtualaddress to a physical address of a tile and optionally a cache lineindex. The MMU 245 may include address translation lookaside buffers(TLB) or caches that may reside within the graphics multiprocessor 234or the L1 cache or processing cluster 214. The physical address isprocessed to distribute surface data access locality to allow efficientrequest interleaving among partition units. The cache line index may beused to determine whether a request for a cache line is a hit or miss.

In graphics and computing applications, a processing cluster 214 may beconfigured such that each graphics multiprocessor 234 is coupled to atexture unit 236 for performing texture mapping operations, e.g.,determining texture sample positions, reading texture data, andfiltering the texture data. Texture data is read from an internaltexture L1 cache (not shown) or in some embodiments from the L1 cachewithin graphics multiprocessor 234 and is fetched from an L2 cache,local parallel processor memory, or system memory, as needed. Eachgraphics multiprocessor 234 outputs processed tasks to the data crossbar240 to provide the processed task to another processing cluster 214 forfurther processing or to store the processed task in an L2 cache, localparallel processor memory, or system memory via the memory crossbar 216.A preROP 242 (pre-raster operations unit) is configured to receive datafrom graphics multiprocessor 234, direct data to ROP units, which may belocated with partition units as described herein (e.g., partition units220A-220N of FIG. 2A). The preROP 242 unit can perform optimizations forcolor blending, organize pixel color data, and perform addresstranslations.

It will be appreciated that the core architecture described herein isillustrative and that variations and modifications are possible. Anynumber of processing units, e.g., graphics multiprocessor 234, textureunits 236, preROPs 242, etc., may be included within a processingcluster 214. Further, while only one processing cluster 214 is shown, aparallel processing unit as described herein may include any number ofinstances of the processing cluster 214. Optionally, each processingcluster 214 can be configured to operate independently of otherprocessing clusters 214 using separate and distinct processing units, L1caches, L2 caches, etc.

FIG. 2D shows an example of the graphics multiprocessor 234 in which thegraphics multiprocessor 234 couples with the pipeline manager 232 of theprocessing cluster 214. The graphics multiprocessor 234 has an executionpipeline including but not limited to an instruction cache 252, aninstruction unit 254, an address mapping unit 256, a register file 258,one or more general purpose graphics processing unit (GPGPU) cores 262,and one or more load/store units 266. The GPGPU cores 262 and load/storeunits 266 are coupled with cache memory 272 and shared memory 270 via amemory and cache interconnect 268. The graphics multiprocessor 234 mayadditionally include tensor and/or ray-tracing cores 263 that includehardware logic to accelerate matrix and/or ray-tracing operations.

The instruction cache 252 may receive a stream of instructions toexecute from the pipeline manager 232. The instructions are cached inthe instruction cache 252 and dispatched for execution by theinstruction unit 254. The instruction unit 254 can dispatch instructionsas thread groups (e.g., warps), with each thread of the thread groupassigned to a different execution unit within GPGPU core 262. Aninstruction can access any of a local, shared, or global address spaceby specifying an address within a unified address space. The addressmapping unit 256 can be used to translate addresses in the unifiedaddress space into a distinct memory address that can be accessed by theload/store units 266.

The register file 258 provides a set of registers for the functionalunits of the graphics multiprocessor 234. The register file 258 providestemporary storage for operands connected to the data paths of thefunctional units (e.g., GPGPU cores 262, load/store units 266) of thegraphics multiprocessor 234. The register file 258 may be dividedbetween each of the functional units such that each functional unit isallocated a dedicated portion of the register file 258. For example, theregister file 258 may be divided between the different warps beingexecuted by the graphics multiprocessor 234.

The GPGPU cores 262 can each include floating point units (FPUs) and/orinteger arithmetic logic units (ALUs) that are used to executeinstructions of the graphics multiprocessor 234. In someimplementations, the GPGPU cores 262 can include hardware logic that mayotherwise reside within the tensor and/or ray-tracing cores 263. TheGPGPU cores 262 can be similar in architecture or can differ inarchitecture. For example and in one embodiment, a first portion of theGPGPU cores 262 include a single precision FPU and an integer ALU whilea second portion of the GPGPU cores include a double precision FPU.Optionally, the FPUs can implement the IEEE 754-2008 standard forfloating point arithmetic or enable variable precision floating pointarithmetic. The graphics multiprocessor 234 can additionally include oneor more fixed function or special function units to perform specificfunctions such as copy rectangle or pixel blending operations. One ormore of the GPGPU cores can also include fixed or special functionlogic.

The GPGPU cores 262 may include SIMD logic capable of performing asingle instruction on multiple sets of data. Optionally, GPGPU cores 262can physically execute SIMD4, SIMD8, and SIMD16 instructions andlogically execute SIMD1, SIMD2, and SIMD32 instructions. The SIMDinstructions for the GPGPU cores can be generated at compile time by ashader compiler or automatically generated when executing programswritten and compiled for single program multiple data (SPMD) or SIMTarchitectures. Multiple threads of a program configured for the SIMTexecution model can be executed via a single SIMD instruction. Forexample and in one embodiment, eight SIMT threads that perform the sameor similar operations can be executed in parallel via a single SIMD8logic unit.

The memory and cache interconnect 268 is an interconnect network thatconnects each of the functional units of the graphics multiprocessor 234to the register file 258 and to the shared memory 270. For example, thememory and cache interconnect 268 is a crossbar interconnect that allowsthe load/store unit 266 to implement load and store operations betweenthe shared memory 270 and the register file 258. The register file 258can operate at the same frequency as the GPGPU cores 262, thus datatransfer between the GPGPU cores 262 and the register file 258 is verylow latency. The shared memory 270 can be used to enable communicationbetween threads that execute on the functional units within the graphicsmultiprocessor 234. The cache memory 272 can be used as a data cache forexample, to cache texture data communicated between the functional unitsand the texture unit 236. The shared memory 270 can also be used as aprogram managed cached. The shared memory 270 and the cache memory 272can couple with the data crossbar 240 to enable communication with othercomponents of the processing cluster. Threads executing on the GPGPUcores 262 can programmatically store data within the shared memory inaddition to the automatically cached data that is stored within thecache memory 272.

FIG. 3A-3C illustrate additional graphics multiprocessors, according toembodiments. FIG. 3A-3B illustrate graphics multiprocessors 325, 350,which are related to the graphics multiprocessor 234 of FIG. 2C and maybe used in place of one of those. Therefore, the disclosure of anyfeatures in combination with the graphics multiprocessor 234 herein alsodiscloses a corresponding combination with the graphicsmultiprocessor(s) 325, 350, but is not limited to such. FIG. 3Cillustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N, which correspond to the graphics multiprocessors 325,350. The illustrated graphics multiprocessors 325, 350 and themulti-core groups 365A-365N can be streaming multiprocessors (SM)capable of simultaneous execution of a large number of executionthreads.

The graphics multiprocessor 325 of FIG. 3A includes multiple additionalinstances of execution resource units relative to the graphicsmultiprocessor 234 of FIG. 2D. For example, the graphics multiprocessor325 can include multiple instances of the instruction unit 332A-332B,register file 334A-334B, and texture unit(s) 344A-344B. The graphicsmultiprocessor 325 also includes multiple sets of graphics or computeexecution units (e.g., GPGPU core 336A-336B, tensor core 337A-337B,ray-tracing core 338A-338B) and multiple sets of load/store units340A-340B. The execution resource units have a common instruction cache330, texture and/or data cache memory 342, and shared memory 346.

The various components can communicate via an interconnect fabric 327.The interconnect fabric 327 may include one or more crossbar switches toenable communication between the various components of the graphicsmultiprocessor 325. The interconnect fabric 327 may be a separate,high-speed network fabric layer upon which each component of thegraphics multiprocessor 325 is stacked. The components of the graphicsmultiprocessor 325 communicate with remote components via theinterconnect fabric 327. For example, the cores 336A-336B, 337A-337B,and 338A-338B can each communicate with shared memory 346 via theinterconnect fabric 327. The interconnect fabric 327 can arbitratecommunication within the graphics multiprocessor 325 to ensure a fairbandwidth allocation between components.

The graphics multiprocessor 350 of FIG. 3B includes multiple sets ofexecution resources 356A-356D, where each set of execution resourceincludes multiple instruction units, register files, GPGPU cores, andload store units, as illustrated in FIG. 2D and FIG. 3A. The executionresources 356A-356D can work in concert with texture unit(s) 360A-360Dfor texture operations, while sharing an instruction cache 354, andshared memory 353. For example, the execution resources 356A-356D canshare an instruction cache 354 and shared memory 353, as well asmultiple instances of a texture and/or data cache memory 358A-358B. Thevarious components can communicate via an interconnect fabric 352similar to the interconnect fabric 327 of FIG. 3A.

Persons skilled in the art will understand that the architecturedescribed in FIGS. 1, 2A-2D, and 3A-3B are descriptive and not limitingas to the scope of the present embodiments. Thus, the techniquesdescribed herein may be implemented on any properly configuredprocessing unit, including, without limitation, one or more mobileapplication processors, one or more desktop or server central processingunits (CPUs) including multi-core CPUs, one or more parallel processingunits, such as the parallel processing unit 202 of FIG. 2A, as well asone or more graphics processors or special purpose processing units,without departure from the scope of the embodiments described herein.

The parallel processor or GPGPU as described herein may becommunicatively coupled to host/processor cores to accelerate graphicsoperations, machine-learning operations, pattern analysis operations,and various general-purpose GPU (GPGPU) functions. The GPU may becommunicatively coupled to the host processor/cores over a bus or otherinterconnect (e.g., a high-speed interconnect such as PCIe, NVLink, orother known protocols, standardized protocols, or proprietaryprotocols). In other embodiments, the GPU may be integrated on the samepackage or chip as the cores and communicatively coupled to the coresover an internal processor bus/interconnect (i.e., internal to thepackage or chip). Regardless of the manner in which the GPU isconnected, the processor cores may allocate work to the GPU in the formof sequences of commands/instructions contained in a work descriptor.The GPU then uses dedicated circuitry/logic for efficiently processingthese commands/instructions.

FIG. 3C illustrates a graphics processing unit (GPU) 380 which includesdedicated sets of graphics processing resources arranged into multi-coregroups 365A-365N. While the details of only a single multi-core group365A are provided, it will be appreciated that the other multi-coregroups 365B-365N may be equipped with the same or similar sets ofgraphics processing resources. Details described with respect to themulti-core groups 365A-365N may also apply to any graphicsmultiprocessor 234, 325, 350 described herein.

As illustrated, a multi-core group 365A may include a set of graphicscores 370, a set of tensor cores 371, and a set of ray tracing cores372. A scheduler/dispatcher 368 schedules and dispatches the graphicsthreads for execution on the various cores 370, 371, 372. A set ofregister files 369 store operand values used by the cores 370, 371, 372when executing the graphics threads. These may include, for example,integer registers for storing integer values, floating point registersfor storing floating point values, vector registers for storing packeddata elements (integer and/or floating-point data elements) and tileregisters for storing tensor/matrix values. The tile registers may beimplemented as combined sets of vector registers.

One or more combined level 1 (L1) caches and shared memory units 373store graphics data such as texture data, vertex data, pixel data, raydata, bounding volume data, etc., locally within each multi-core group365A. One or more texture units 374 can also be used to performtexturing operations, such as texture mapping and sampling. A Level 2(L2) cache 375 shared by all or a subset of the multi-core groups365A-365N stores graphics data and/or instructions for multipleconcurrent graphics threads. As illustrated, the L2 cache 375 may beshared across a plurality of multi-core groups 365A-365N. One or morememory controllers 367 couple the GPU 380 to a memory 366 which may be asystem memory (e.g., DRAM) and/or a dedicated graphics memory (e.g.,GDDR6 memory).

Input/output (I/O) circuitry 363 couples the GPU 380 to one or more I/Odevices 362 such as digital signal processors (DSPs), networkcontrollers, or user input devices. An on-chip interconnect may be usedto couple the I/O devices 362 to the GPU 380 and memory 366. One or moreI/O memory management units (IOMMUs) 364 of the I/O circuitry 363 couplethe I/O devices 362 directly to the system memory 366. Optionally, theIOMMU 364 manages multiple sets of page tables to map virtual addressesto physical addresses in system memory 366. The I/O devices 362, CPU(s)361, and GPU(s) 380 may then share the same virtual address space.

In one implementation of the IOMMU 364, the IOMMU 364 supportsvirtualization. In this case, it may manage a first set of page tablesto map guest/graphics virtual addresses to guest/graphics physicaladdresses and a second set of page tables to map the guest/graphicsphysical addresses to system/host physical addresses (e.g., withinsystem memory 366). The base addresses of each of the first and secondsets of page tables may be stored in control registers and swapped outon a context switch (e.g., so that the new context is provided withaccess to the relevant set of page tables). While not illustrated inFIG. 3C, each of the cores 370, 371, 372 and/or multi-core groups365A-365N may include translation lookaside buffers (TLBs) to cacheguest virtual to guest physical translations, guest physical to hostphysical translations, and guest virtual to host physical translations.

The CPUs 361, GPUs 380, and I/O devices 362 may be integrated on asingle semiconductor chip and/or chip package. The illustrated memory366 may be integrated on the same chip or may be coupled to the memorycontrollers 367 via an off-chip interface. In one implementation, thememory 366 comprises GDDR6 memory which shares the same virtual addressspace as other physical system-level memories, although the underlyingprinciples described herein are not limited to this specificimplementation.

The tensor cores 371 may include a plurality of execution unitsspecifically designed to perform matrix operations, which are thefundamental compute operation used to perform deep learning operations.For example, simultaneous matrix multiplication operations may be usedfor neural network training and inferencing. The tensor cores 371 mayperform matrix processing using a variety of operand precisionsincluding single precision floating-point (e.g., 32 bits),half-precision floating point (e.g., 16 bits), integer words (16 bits),bytes (8 bits), and half-bytes (4 bits). For example, a neural networkimplementation extracts features of each rendered scene, potentiallycombining details from multiple frames, to construct a high-qualityfinal image.

In deep learning implementations, parallel matrix multiplication workmay be scheduled for execution on the tensor cores 371. The training ofneural networks, in particular, requires a significant number matrix dotproduct operations. In order to process an inner-product formulation ofan N×N×N matrix multiply, the tensor cores 371 may include at least Ndot-product processing elements. Before the matrix multiply begins, oneentire matrix is loaded into tile registers and at least one column of asecond matrix is loaded each cycle for N cycles. Each cycle, there are Ndot products that are processed.

Matrix elements may be stored at different precisions depending on theparticular implementation, including 16-bit words, 8-bit bytes (e.g.,INT8) and 4-bit half-bytes (e.g., INT4). Different precision modes maybe specified for the tensor cores 371 to ensure that the most efficientprecision is used for different workloads (e.g., such as inferencingworkloads which can tolerate quantization to bytes and half-bytes).Supported formats additionally include 64-bit floating point (FP64) andnon-IEEE floating point formats such as the bfloat16 format (e.g., Brainfloating point), a 16-bit floating point format with one sign bit, eightexponents bits, and eight significand bits, of which seven areexplicitly stored. One embodiment includes support for a reducedprecision tensor-float format (TF32), which has the range of FP32(8-bits) with the precision of FP16 (10-bits). Reduced precision TF32operations can be performed on FP32 inputs and produce FP32 outputs athigher performance relative to FP32 and increased precision relative toFP16.

In one embodiment the tensor cores 371 support a sparse mode ofoperation for matrices in which the vast majority of values are zero.The tensor cores 371 include support for sparse input matrices that areencoded in a sparse matrix representation (e.g., coordinate listencoding (COO), compressed sparse row (CSR), compress sparse column(CSC), etc.). The tensor cores 371 also include support for compressedsparse matrix representations in the event that the sparse matrixrepresentation may be further compressed. Compressed, encoded, and/orcompressed and encoded matrix data, along with associated compressionand/or encoding metadata, can be ready by the tensor cores 371 and thenon-zero values can be extracted. For example, for a given input matrixA, a non-zero value can be loaded from the compressed and/or encodedrepresentation of at least a portion of matrix A. Based on the locationin matrix A for the non-zero value, which may be determined from indexor coordinate metadata associated with the non-zero value, acorresponding value in input matrix B may be loaded. Depending on theoperation to be performed (e.g., multiply), the load of the value frominput matrix B may be bypassed if the corresponding value is a zerovalue. In one embodiment, the pairings of values for certain operations,such as multiply operations, may be pre-scanned by scheduler logic andonly operations between non-zero inputs are scheduled. Depending on thedimensions of matrix A and matrix B and the operation to be performed,output matrix C may be dense or sparse. Where output matrix C is sparse,and depending on the configuration of the tensor cores 371, outputmatrix C may be output in a compressed format, a sparse encoding, or acompressed sparse encoding.

The ray tracing cores 372 may accelerate ray tracing operations for bothreal-time ray tracing and non-real-time ray tracing implementations. Inparticular, the ray tracing cores 372 may include raytraversal/intersection circuitry for performing ray traversal usingbounding volume hierarchies (BVHs) and identifying intersections betweenrays and primitives enclosed within the BVH volumes. The ray tracingcores 372 may also include circuitry for performing depth testing andculling (e.g., using a Z buffer or similar arrangement). In oneimplementation, the ray tracing cores 372 perform traversal andintersection operations in concert with the image denoising techniquesdescribed herein, at least a portion of which may be executed on thetensor cores 371. For example, the tensor cores 371 may implement a deeplearning neural network to perform denoising of frames generated by theray tracing cores 372. However, the CPU(s) 361, graphics cores 370,and/or ray tracing cores 372 may also implement all or a portion of thedenoising and/or deep learning algorithms.

In addition, as described above, a distributed approach to denoising maybe employed in which the GPU 380 is in a computing device coupled toother computing devices over a network or high-speed interconnect. Inthis distributed approach, the interconnected computing devices mayshare neural network learning/training data to improve the speed withwhich the overall system learns to perform denoising for different typesof image frames and/or different graphics applications.

The ray tracing cores 372 may process all BVH traversal and/orray-primitive intersections, saving the graphics cores 370 from beingoverloaded with thousands of instructions per ray. For example, each raytracing core 372 includes a first set of specialized circuitry forperforming bounding box tests (e.g., for traversal operations) and/or asecond set of specialized circuitry for performing the ray-triangleintersection tests (e.g., intersecting rays which have been traversed).Thus, for example, the multi-core group 365A can simply launch a rayprobe, and the ray tracing cores 372 independently perform ray traversaland intersection and return hit data (e.g., a hit, no hit, multiplehits, etc.) to the thread context. The other cores 370, 371 are freed toperform other graphics or compute work while the ray tracing cores 372perform the traversal and intersection operations.

Optionally, each ray tracing core 372 may include a traversal unit toperform BVH testing operations and/or an intersection unit whichperforms ray-primitive intersection tests. The intersection unitgenerates a “hit”, “no hit”, or “multiple hit” response, which itprovides to the appropriate thread. During the traversal andintersection operations, the execution resources of the other cores(e.g., graphics cores 370 and tensor cores 371) are freed to performother forms of graphics work.

In one optional embodiment described below, a hybrid rasterization/raytracing approach is used in which work is distributed between thegraphics cores 370 and ray tracing cores 372.

The ray tracing cores 372 (and/or other cores 370, 371) may includehardware support for a ray tracing instruction set such as Microsoft'sDirectX Ray Tracing (DXR) which includes a DispatchRays command, as wellas ray-generation, closest-hit, any-hit, and miss shaders, which enablethe assignment of unique sets of shaders and textures for each object.Another ray tracing platform which may be supported by the ray tracingcores 372, graphics cores 370 and tensor cores 371 is Vulkan 1.1.85.Note, however, that the underlying principles described herein are notlimited to any particular ray tracing ISA.

In general, the various cores 372, 371, 370 may support a ray tracinginstruction set that includes instructions/functions for one or more ofray generation, closest hit, any hit, ray-primitive intersection,per-primitive and hierarchical bounding box construction, miss, visit,and exceptions. More specifically, a preferred embodiment includes raytracing instructions to perform one or more of the following functions:

Ray Generation—Ray generation instructions may be executed for eachpixel, sample, or other user-defined work assignment.

Closest Hit—A closest hit instruction may be executed to locate theclosest intersection point of a ray with primitives within a scene.

Any Hit—An any hit instruction identifies multiple intersections betweena ray and primitives within a scene, potentially to identify a newclosest intersection point.

Intersection—An intersection instruction performs a ray-primitiveintersection test and outputs a result.

Per-primitive Bounding box Construction—This instruction builds abounding box around a given primitive or group of primitives (e.g., whenbuilding a new BVH or other acceleration data structure).

Miss—Indicates that a ray misses all geometry within a scene, orspecified region of a scene.

Visit—Indicates the children volumes a ray will traverse.

Exceptions—Includes various types of exception handlers (e.g., invokedfor various error conditions).

In one embodiment the ray tracing cores 372 may be adapted to accelerategeneral-purpose compute operations that can be accelerated usingcomputational techniques that are analogous to ray intersection tests. Acompute framework can be provided that enables shader programs to becompiled into low level instructions and/or primitives that performgeneral-purpose compute operations via the ray tracing cores. Exemplarycomputational problems that can benefit from compute operationsperformed on the ray tracing cores 372 include computations involvingbeam, wave, ray, or particle propagation within a coordinate space.Interactions associated with that propagation can be computed relativeto a geometry or mesh within the coordinate space. For example,computations associated with electromagnetic signal propagation throughan environment can be accelerated via the use of instructions orprimitives that are executed via the ray tracing cores. Diffraction andreflection of the signals by objects in the environment can be computedas direct ray-tracing analogies.

Ray tracing cores 372 can also be used to perform computations that arenot directly analogous to ray tracing. For example, mesh projection,mesh refinement, and volume sampling computations can be acceleratedusing the ray tracing cores 372. Generic coordinate space calculations,such as nearest neighbor calculations can also be performed. Forexample, the set of points near a given point can be discovered bydefining a bounding box in the coordinate space around the point. BVHand ray probe logic within the ray tracing cores 372 can then be used todetermine the set of point intersections within the bounding box. Theintersections constitute the origin point and the nearest neighbors tothat origin point. Computations that are performed using the ray tracingcores 372 can be performed in parallel with computations performed onthe graphics cores 372 and tensor cores 371. A shader compiler can beconfigured to compile a compute shader or other general-purpose graphicsprocessing program into low level primitives that can be parallelizedacross the graphics cores 370, tensor cores 371, and ray tracing cores372.

Techniques for GPU to Host Processor Interconnection

FIG. 4A illustrates an exemplary architecture in which a plurality ofGPUs 410-413, e.g. such as the parallel processors 200 shown in FIG. 2A,are communicatively coupled to a plurality of multi-core processors405-406 over high-speed links 440A-440D (e.g., buses, point-to-pointinterconnects, etc.). The high-speed links 440A-440D may support acommunication throughput of 4 GB/s, 30 GB/s, 80 GB/s or higher,depending on the implementation. Various interconnect protocols may beused including, but not limited to, PCIe 4.0 or 5.0 and NVLink 2.0.However, the underlying principles described herein are not limited toany particular communication protocol or throughput.

Two or more of the GPUs 410-413 may be interconnected over high-speedlinks 442A-442B, which may be implemented using the same or differentprotocols/links than those used for high-speed links 440A-440D.Similarly, two or more of the multi-core processors 405-406 may beconnected over high speed link 443 which may be symmetricmulti-processor (SMP) buses operating at 20 GB/s, 30 GB/s, 120 GB/s orlower or higher speeds. Alternatively, all communication between thevarious system components shown in FIG. 4A may be accomplished using thesame protocols/links (e.g., over a common interconnection fabric). Asmentioned, however, the underlying principles described herein are notlimited to any particular type of interconnect technology.

Each multi-core processor 405-406 may be communicatively coupled to aprocessor memory 401-402, via memory interconnects 430A-430B,respectively, and each GPU 410-413 is communicatively coupled to GPUmemory 420-423 over GPU memory interconnects 450A-450D, respectively.The memory interconnects 430A-430B and 450A-450D may utilize the same ordifferent memory access technologies. By way of example, and notlimitation, the processor memories 401-402 and GPU memories 420-423 maybe volatile memories such as dynamic random-access memories (DRAMs)(including stacked DRAMs), Graphics DDR SDRAM (GDDR) (e.g., GDDR5,GDDR6), or High Bandwidth Memory (HBM) and/or may be non-volatilememories such as 3D XPoint/Optane or Nano-Ram. For example, some portionof the memories may be volatile memory and another portion may benon-volatile memory (e.g., using a two-level memory (2LM) hierarchy). Amemory subsystem as described herein may be compatible with a number ofmemory technologies, such as Double Data Rate versions released by JEDEC(Joint Electronic Device Engineering Council).

As described below, although the various processors 405-406 and GPUs410-413 may be physically coupled to a particular memory 401-402,420-423, respectively, a unified memory architecture may be implementedin which the same virtual system address space (also referred to as the“effective address” space) is distributed among all of the variousphysical memories. For example, processor memories 401-402 may eachcomprise 64 GB of the system memory address space and GPU memories420-423 may each comprise 32 GB of the system memory address space(resulting in a total of 256 GB addressable memory in this example).

FIG. 4B illustrates additional optional details for an interconnectionbetween a multi-core processor 407 and a graphics acceleration module446. The graphics acceleration module 446 may include one or more GPUchips integrated on a line card which is coupled to the processor 407via the high-speed link 440. Alternatively, the graphics accelerationmodule 446 may be integrated on the same package or chip as theprocessor 407.

The illustrated processor 407 includes a plurality of cores 460A-460D,each with a translation lookaside buffer 461A-461D and one or morecaches 462A-462D. The cores may include various other components forexecuting instructions and processing data which are not illustrated toavoid obscuring the underlying principles of the components describedherein (e.g., instruction fetch units, branch prediction units,decoders, execution units, reorder buffers, etc.). The caches 462A-462Dmay comprise level 1 (L1) and level 2 (L2) caches. In addition, one ormore shared caches 456 may be included in the caching hierarchy andshared by sets of the cores 460A-460D. For example, one embodiment ofthe processor 407 includes 24 cores, each with its own L1 cache, twelveshared L2 caches, and twelve shared L3 caches. In this embodiment, oneof the L2 and L3 caches are shared by two adjacent cores. The processor407 and the graphics accelerator integration module 446 connect withsystem memory 441, which may include processor memories 401-402.

Coherency is maintained for data and instructions stored in the variouscaches 462A-462D, 456 and system memory 441 via inter-core communicationover a coherence bus 464. For example, each cache may have cachecoherency logic/circuitry associated therewith to communicate to overthe coherence bus 464 in response to detected reads or writes toparticular cache lines. In one implementation, a cache snooping protocolis implemented over the coherence bus 464 to snoop cache accesses. Cachesnooping/coherency techniques are well understood by those of skill inthe art and will not be described in detail here to avoid obscuring theunderlying principles described herein.

A proxy circuit 425 may be provided that communicatively couples thegraphics acceleration module 446 to the coherence bus 464, allowing thegraphics acceleration module 446 to participate in the cache coherenceprotocol as a peer of the cores. In particular, an interface 435provides connectivity to the proxy circuit 425 over high-speed link 440(e.g., a PCIe bus, NVLink, etc.) and an interface 437 connects thegraphics acceleration module 446 to the high-speed link 440.

In one implementation, an accelerator integration circuit 436 providescache management, memory access, context management, and interruptmanagement services on behalf of a plurality of graphics processingengines 431, 432, N of the graphics acceleration module 446. Thegraphics processing engines 431, 432, N may each comprise a separategraphics processing unit (GPU). Alternatively, the graphics processingengines 431, 432, N may comprise different types of graphics processingengines within a GPU such as graphics execution units, media processingengines (e.g., video encoders/decoders), samplers, and blit engines. Inother words, the graphics acceleration module may be a GPU with aplurality of graphics processing engines 431-432, N or the graphicsprocessing engines 431-432, N may be individual GPUs integrated on acommon package, line card, or chip.

The accelerator integration circuit 436 may include a memory managementunit (MMU) 439 for performing various memory management functions suchas virtual-to-physical memory translations (also referred to aseffective-to-real memory translations) and memory access protocols foraccessing system memory 441. The MMU 439 may also include a translationlookaside buffer (TLB) (not shown) for caching the virtual/effective tophysical/real address translations. In one implementation, a cache 438stores commands and data for efficient access by the graphics processingengines 431, 432, N. The data stored in cache 438 and graphics memories433-434, M may be kept coherent with the core caches 462A-462D, 456 andsystem memory 441. As mentioned, this may be accomplished via proxycircuit 425 which takes part in the cache coherency mechanism on behalfof cache 438 and memories 433-434, M (e.g., sending updates to the cache438 related to modifications/accesses of cache lines on processor caches462A-462D, 456 and receiving updates from the cache 438).

A set of registers 445 store context data for threads executed by thegraphics processing engines 431-432, N and a context management circuit448 manages the thread contexts. For example, the context managementcircuit 448 may perform save and restore operations to save and restorecontexts of the various threads during contexts switches (e.g., where afirst thread is saved and a second thread is restored so that the secondthread can be execute by a graphics processing engine). For example, ona context switch, the context management circuit 448 may store currentregister values to a designated region in memory (e.g., identified by acontext pointer). It may then restore the register values when returningto the context. An interrupt management circuit 447, for example, mayreceive and processes interrupts received from system devices.

In one implementation, virtual/effective addresses from a graphicsprocessing engine 431 are translated to real/physical addresses insystem memory 441 by the MMU 439. Optionally, the acceleratorintegration circuit 436 supports multiple (e.g., 4, 8, 16) graphicsaccelerator modules 446 and/or other accelerator devices. The graphicsaccelerator module 446 may be dedicated to a single application executedon the processor 407 or may be shared between multiple applications.Optionally, a virtualized graphics execution environment is provided inwhich the resources of the graphics processing engines 431-432, N areshared with multiple applications, virtual machines (VMs), orcontainers. The resources may be subdivided into “slices” which areallocated to different VMs and/or applications based on the processingrequirements and priorities associated with the VMs and/or applications.VMs and containers can be used interchangeably herein.

A virtual machine (VM) can be software that runs an operating system andone or more applications. A VM can be defined by specification,configuration files, virtual disk file, non-volatile random accessmemory (NVRAM) setting file, and the log file and is backed by thephysical resources of a host computing platform. A VM can include anoperating system (OS) or application environment that is installed onsoftware, which imitates dedicated hardware. The end user has the sameexperience on a virtual machine as they would have on dedicatedhardware. Specialized software, called a hypervisor, emulates the PCclient or server's CPU, memory, hard disk, network and other hardwareresources completely, enabling virtual machines to share the resources.The hypervisor can emulate multiple virtual hardware platforms that areisolated from each other, allowing virtual machines to run Linux®,Windows® Server, VMware ESXi, and other operating systems on the sameunderlying physical host.

A container can be a software package of applications, configurationsand dependencies so the applications run reliably on one computingenvironment to another. Containers can share an operating systeminstalled on the server platform and run as isolated processes. Acontainer can be a software package that contains everything thesoftware needs to run such as system tools, libraries, and settings.Containers are not installed like traditional software programs, whichallows them to be isolated from the other software and the operatingsystem itself. The isolated nature of containers provides severalbenefits. First, the software in a container will run the same indifferent environments. For example, a container that includes PHP andMySQL can run identically on both a Linux® computer and a Windows®machine. Second, containers provide added security since the softwarewill not affect the host operating system. While an installedapplication may alter system settings and modify resources, such as theWindows registry, a container can only modify settings within thecontainer.

Thus, the accelerator integration circuit 436 acts as a bridge to thesystem for the graphics acceleration module 446 and provides addresstranslation and system memory cache services. In one embodiment, tofacilitate the bridging functionality, the accelerator integrationcircuit 436 may also include shared I/O 497 (e.g., PCIe, USB, or others)and hardware to enable system control of voltage, clocking, performance,thermals, and security. The shared I/O 497 may utilize separate physicalconnections or may traverse the high-speed link 440. In addition, theaccelerator integration circuit 436 may provide virtualizationfacilities for the host processor to manage virtualization of thegraphics processing engines, interrupts, and memory management.

Because hardware resources of the graphics processing engines 431-432, Nare mapped explicitly to the real address space seen by the hostprocessor 407, any host processor can address these resources directlyusing an effective address value. One optional function of theaccelerator integration circuit 436 is the physical separation of thegraphics processing engines 431-432, N so that they appear to the systemas independent units.

One or more graphics memories 433-434, M may be coupled to each of thegraphics processing engines 431-432, N, respectively. The graphicsmemories 433-434, M store instructions and data being processed by eachof the graphics processing engines 431-432, N. The graphics memories433-434, M may be volatile memories such as DRAMs (including stackedDRAMs), GDDR memory (e.g., GDDR5, GDDR6), or HBM, and/or may benon-volatile memories such as 3D XPoint/Optane, Samsung Z-NAND, orNano-Ram.

To reduce data traffic over the high-speed link 440, biasing techniquesmay be used to ensure that the data stored in graphics memories 433-434,M is data which will be used most frequently by the graphics processingengines 431-432, N and preferably not used by the cores 460A-460D (atleast not frequently). Similarly, the biasing mechanism attempts to keepdata needed by the cores (and preferably not the graphics processingengines 431-432, N) within the caches 462A-462D, 456 of the cores andsystem memory 441.

According to a variant shown in FIG. 4C the accelerator integrationcircuit 436 is integrated within the processor 407. The graphicsprocessing engines 431-432, N communicate directly over the high-speedlink 440 to the accelerator integration circuit 436 via interface 437and interface 435 (which, again, may be utilize any form of bus orinterface protocol). The accelerator integration circuit 436 may performthe same operations as those described with respect to FIG. 4B, butpotentially at a higher throughput given its close proximity to thecoherence bus 464 and caches 462A-462D, 456.

The embodiments described may support different programming modelsincluding a dedicated-process programming model (no graphicsacceleration module virtualization) and shared programming models (withvirtualization). The latter may include programming models which arecontrolled by the accelerator integration circuit 436 and programmingmodels which are controlled by the graphics acceleration module 446.

In the embodiments of the dedicated process model, graphics processingengines 431, 432, . . . N may be dedicated to a single application orprocess under a single operating system. The single application canfunnel other application requests to the graphics engines 431, 432, . .. N, providing virtualization within a VM/partition.

In the dedicated-process programming models, the graphics processingengines 431, 432, . . . , N, may be shared by multiple VM/applicationpartitions. The shared models require a system hypervisor to virtualizethe graphics processing engines 431-432, N to allow access by eachoperating system. For single-partition systems without a hypervisor, thegraphics processing engines 431-432, N are owned by the operatingsystem. In both cases, the operating system can virtualize the graphicsprocessing engines 431-432, N to provide access to each process orapplication.

For the shared programming model, the graphics acceleration module 446or an individual graphics processing engine 431-432, N selects a processelement using a process handle. The process elements may be stored insystem memory 441 and be addressable using the effective address to realaddress translation techniques described herein. The process handle maybe an implementation-specific value provided to the host process whenregistering its context with the graphics processing engine 431-432, N(that is, calling system software to add the process element to theprocess element linked list). The lower 16-bits of the process handlemay be the offset of the process element within the process elementlinked list.

FIG. 4D illustrates an exemplary accelerator integration slice 490. Asused herein, a “slice” comprises a specified portion of the processingresources of the accelerator integration circuit 436. Applicationeffective address space 482 within system memory 441 stores processelements 483. The process elements 483 may be stored in response to GPUinvocations 481 from applications 480 executed on the processor 407. Aprocess element 483 contains the process state for the correspondingapplication 480. A work descriptor (WD) 484 contained in the processelement 483 can be a single job requested by an application or maycontain a pointer to a queue of jobs. In the latter case, the WD 484 isa pointer to the job request queue in the application's address space482.

The graphics acceleration module 446 and/or the individual graphicsprocessing engines 431-432, N can be shared by all or a subset of theprocesses in the system. For example, the technologies described hereinmay include an infrastructure for setting up the process state andsending a WD 484 to a graphics acceleration module 446 to start a job ina virtualized environment.

In one implementation, the dedicated-process programming model isimplementation-specific. In this model, a single process owns thegraphics acceleration module 446 or an individual graphics processingengine 431. Because the graphics acceleration module 446 is owned by asingle process, the hypervisor initializes the accelerator integrationcircuit 436 for the owning partition and the operating systeminitializes the accelerator integration circuit 436 for the owningprocess at the time when the graphics acceleration module 446 isassigned.

In operation, a WD fetch unit 491 in the accelerator integration slice490 fetches the next WD 484 which includes an indication of the work tobe done by one of the graphics processing engines of the graphicsacceleration module 446. Data from the WD 484 may be stored in registers445 and used by the MMU 439, interrupt management circuit 447 and/orcontext management circuit 448 as illustrated. For example, the MMU 439may include segment/page walk circuitry for accessing segment/pagetables 486 within the OS virtual address space 485. The interruptmanagement circuit 447 may process interrupt events 492 received fromthe graphics acceleration module 446. When performing graphicsoperations, an effective address 493 generated by a graphics processingengine 431-432, N is translated to a real address by the MMU 439.

The same set of registers 445 may be duplicated for each graphicsprocessing engine 431-432, N and/or graphics acceleration module 446 andmay be initialized by the hypervisor or operating system. Each of theseduplicated registers may be included in an accelerator integration slice490. In one embodiment, each graphics processing engine 431-432, N maybe presented to the hypervisor 496 as a distinct graphics processordevice. QoS settings can be configured for clients of a specificgraphics processing engine 431-432, N and data isolation between theclients of each engine can be enabled. Exemplary registers that may beinitialized by the hypervisor are shown in Table 1.

TABLE 1 Hypervisor Initialized Registers 1 Slice Control Register 2 RealAddress (RA) Scheduled Processes Area Pointer 3 Authority Mask OverrideRegister 4 Interrupt Vector Table Entry Offset 5 Interrupt Vector TableEntry Limit 6 State Register 7 Logical Partition ID 8 Real address (RA)Hypervisor Accelerator Utilization Record Pointer 9 Storage DescriptionRegister

Exemplary registers that may be initialized by the operating system areshown in Table 2.

TABLE 2 Operating System Initialized Registers 1 Process and ThreadIdentification 2 Effective Address (EA) Context Save/Restore Pointer 3Virtual Address (VA) Accelerator Utilization Record Pointer 4 VirtualAddress (VA) Storage Segment Table Pointer 5 Authority Mask 6 Workdescriptor

Each WD 484 may be specific to a particular graphics acceleration module446 and/or graphics processing engine 431-432, N. It contains all theinformation a graphics processing engine 431-432, N requires to do itswork or it can be a pointer to a memory location where the applicationhas set up a command queue of work to be completed.

FIG. 4E illustrates additional optional details of a shared model. Itincludes a hypervisor real address space 498 in which a process elementlist 499 is stored. The hypervisor real address space 498 is accessiblevia a hypervisor 496 which virtualizes the graphics acceleration moduleengines for the operating system 495.

The shared programming models allow for all or a subset of processesfrom all or a subset of partitions in the system to use a graphicsacceleration module 446. There are two programming models where thegraphics acceleration module 446 is shared by multiple processes andpartitions: time-sliced shared and graphics directed shared.

In this model, the system hypervisor 496 owns the graphics accelerationmodule 446 and makes its function available to all operating systems495. For a graphics acceleration module 446 to support virtualization bythe system hypervisor 496, the graphics acceleration module 446 mayadhere to the following requirements: 1) An application's job requestmust be autonomous (that is, the state does not need to be maintainedbetween jobs), or the graphics acceleration module 446 must provide acontext save and restore mechanism. 2) An application's job request isguaranteed by the graphics acceleration module 446 to complete in aspecified amount of time, including any translation faults, or thegraphics acceleration module 446 provides the ability to preempt theprocessing of the job. 3) The graphics acceleration module 446 must beguaranteed fairness between processes when operating in the directedshared programming model.

For the shared model, the application 480 may be required to make anoperating system 495 system call with a graphics acceleration module 446type, a work descriptor (WD), an authority mask register (AMR) value,and a context save/restore area pointer (CSRP). The graphicsacceleration module 446 type describes the targeted accelerationfunction for the system call. The graphics acceleration module 446 typemay be a system-specific value. The WD is formatted specifically for thegraphics acceleration module 446 and can be in the form of a graphicsacceleration module 446 command, an effective address pointer to auser-defined structure, an effective address pointer to a queue ofcommands, or any other data structure to describe the work to be done bythe graphics acceleration module 446. In one embodiment, the AMR valueis the AMR state to use for the current process. The value passed to theoperating system is similar to an application setting the AMR. If theaccelerator integration circuit 436 and graphics acceleration module 446implementations do not support a User Authority Mask Override Register(UAMOR), the operating system may apply the current UAMOR value to theAMR value before passing the AMR in the hypervisor call. The hypervisor496 may optionally apply the current Authority Mask Override Register(AMOR) value before placing the AMR into the process element 483. TheCSRP may be one of the registers 445 containing the effective address ofan area in the application's address space 482 for the graphicsacceleration module 446 to save and restore the context state. Thispointer is optional if no state is required to be saved between jobs orwhen a job is preempted. The context save/restore area may be pinnedsystem memory.

Upon receiving the system call, the operating system 495 may verify thatthe application 480 has registered and been given the authority to usethe graphics acceleration module 446. The operating system 495 thencalls the hypervisor 496 with the information shown in Table 3.

TABLE 3 OS to Hypervisor Call Parameters 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)

Upon receiving the hypervisor call, the hypervisor 496 verifies that theoperating system 495 has registered and been given the authority to usethe graphics acceleration module 446. The hypervisor 496 then puts theprocess element 483 into the process element linked list for thecorresponding graphics acceleration module 446 type. The process elementmay include the information shown in Table 4.

TABLE 4 Process Element Information 1 A work descriptor (WD) 2 AnAuthority Mask Register (AMR) value (potentially masked). 3 An effectiveaddress (EA) Context Save/Restore Area Pointer (CSRP) 4 A process ID(PID) and optional thread ID (TID) 5 A virtual address (VA) acceleratorutilization record pointer (AURP) 6 The virtual address of the storagesegment table pointer (SSTP) 7 A logical interrupt service number (LISN)8 Interrupt vector table, derived from the hypervisor call parameters. 9A state register (SR) value 10 A logical partition ID (LPID) 11 A realaddress (RA) hypervisor accelerator utilization record pointer 12 TheStorage Descriptor Register (SDR)

The hypervisor may initialize a plurality of accelerator integrationslice 490 registers 445.

As illustrated in FIG. 4F, in one optional implementation a unifiedmemory addressable via a common virtual memory address space used toaccess the physical processor memories 401-402 and GPU memories 420-423is employed. In this implementation, operations executed on the GPUs410-413 utilize the same virtual/effective memory address space toaccess the processors memories 401-402 and vice versa, therebysimplifying programmability. A first portion of the virtual/effectiveaddress space may be allocated to the processor memory 401, a secondportion to the second processor memory 402, a third portion to the GPUmemory 420, and so on. The entire virtual/effective memory space(sometimes referred to as the effective address space) may thereby bedistributed across each of the processor memories 401-402 and GPUmemories 420-423, allowing any processor or GPU to access any physicalmemory with a virtual address mapped to that memory.

Bias/coherence management circuitry 494A-494E within one or more of theMMUs 439A-439E may be provided that ensures cache coherence between thecaches of the host processors (e.g., 405) and the GPUs 410-413 andimplements biasing techniques indicating the physical memories in whichcertain types of data should be stored. While multiple instances ofbias/coherence management circuitry 494A-494E are illustrated in FIG.4F, the bias/coherence circuitry may be implemented within the MMU ofone or more host processors 405 and/or within the acceleratorintegration circuit 436.

The GPU-attached memory 420-423 may be mapped as part of system memory,and accessed using shared virtual memory (SVM) technology, but withoutsuffering the typical performance drawbacks associated with full systemcache coherence. The ability to GPU-attached memory 420-423 to beaccessed as system memory without onerous cache coherence overheadprovides a beneficial operating environment for GPU offload. Thisarrangement allows the host processor 405 software to setup operands andaccess computation results, without the overhead of tradition I/O DMAdata copies. Such traditional copies involve driver calls, interruptsand memory mapped I/O (MMIO) accesses that are all inefficient relativeto simple memory accesses. At the same time, the ability to access GPUattached memory 420-423 without cache coherence overheads can becritical to the execution time of an offloaded computation. In caseswith substantial streaming write memory traffic, for example, cachecoherence overhead can significantly reduce the effective writebandwidth seen by a GPU 410-413. The efficiency of operand setup, theefficiency of results access, and the efficiency of GPU computation allplay a role in determining the effectiveness of GPU offload.

A selection between GPU bias and host processor bias may be driven by abias tracker data structure. A bias table may be used, for example,which may be a page-granular structure (i.e., controlled at thegranularity of a memory page) that includes 1 or 2 bits per GPU-attachedmemory page. The bias table may be implemented in a stolen memory rangeof one or more GPU-attached memories 420-423, with or without a biascache in the GPU 410-413 (e.g., to cache frequently/recently usedentries of the bias table). Alternatively, the entire bias table may bemaintained within the GPU.

In one implementation, the bias table entry associated with each accessto the GPU-attached memory 420-423 is accessed prior the actual accessto the GPU memory, causing the following operations. First, localrequests from the GPU 410-413 that find their page in GPU bias areforwarded directly to a corresponding GPU memory 420-423. Local requestsfrom the GPU that find their page in host bias are forwarded to theprocessor 405 (e.g., over a high-speed link as discussed above).Optionally, requests from the processor 405 that find the requested pagein host processor bias complete the request like a normal memory read.Alternatively, requests directed to a GPU-biased page may be forwardedto the GPU 410-413. The GPU may then transition the page to a hostprocessor bias if it is not currently using the page.

The bias state of a page can be changed either by a software-basedmechanism, a hardware-assisted software-based mechanism, or, for alimited set of cases, a purely hardware-based mechanism.

One mechanism for changing the bias state employs an API call (e.g.OpenCL), which, in turn, calls the GPU's device driver which, in turn,sends a message (or enqueues a command descriptor) to the GPU directingit to change the bias state and, for some transitions, perform a cacheflushing operation in the host. The cache flushing operation is requiredfor a transition from host processor 405 bias to GPU bias, but is notrequired for the opposite transition.

Cache coherency may be maintained by temporarily rendering GPU-biasedpages uncacheable by the host processor 405. To access these pages, theprocessor 405 may request access from the GPU 410 which may or may notgrant access right away, depending on the implementation. Thus, toreduce communication between the host processor 405 and GPU 410 it isbeneficial to ensure that GPU-biased pages are those which are requiredby the GPU but not the host processor 405 and vice versa.

Graphics Processing Pipeline

FIG. 5 illustrates a graphics processing pipeline 500. A graphicsmultiprocessor, such as graphics multiprocessor 234 as in FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B can implement the illustrated graphics processing pipeline 500.The graphics multiprocessor can be included within the parallelprocessing subsystems as described herein, such as the parallelprocessor 200 of FIG. 2A, which may be related to the parallelprocessor(s) 112 of FIG. 1 and may be used in place of one of those. Thevarious parallel processing systems can implement the graphicsprocessing pipeline 500 via one or more instances of the parallelprocessing unit (e.g., parallel processing unit 202 of FIG. 2A) asdescribed herein. For example, a shader unit (e.g., graphicsmultiprocessor 234 of FIG. 2C) may be configured to perform thefunctions of one or more of a vertex processing unit 504, a tessellationcontrol processing unit 508, a tessellation evaluation processing unit512, a geometry processing unit 516, and a fragment/pixel processingunit 524. The functions of data assembler 502, primitive assemblers 506,514, 518, tessellation unit 510, rasterizer 522, and raster operationsunit 526 may also be performed by other processing engines within aprocessing cluster (e.g., processing cluster 214 of FIG. 2A) and acorresponding partition unit (e.g., partition unit 220A-220N of FIG.2A). The graphics processing pipeline 500 may also be implemented usingdedicated processing units for one or more functions. It is alsopossible that one or more portions of the graphics processing pipeline500 are performed by parallel processing logic within a general-purposeprocessor (e.g., CPU). Optionally, one or more portions of the graphicsprocessing pipeline 500 can access on-chip memory (e.g., parallelprocessor memory 222 as in FIG. 2A) via a memory interface 528, whichmay be an instance of the memory interface 218 of FIG. 2A. The graphicsprocessor pipeline 500 may also be implemented via a multi-core group365A as in FIG. 3C.

The data assembler 502 is a processing unit that may collect vertex datafor surfaces and primitives. The data assembler 502 then outputs thevertex data, including the vertex attributes, to the vertex processingunit 504. The vertex processing unit 504 is a programmable executionunit that executes vertex shader programs, lighting and transformingvertex data as specified by the vertex shader programs. The vertexprocessing unit 504 reads data that is stored in cache, local or systemmemory for use in processing the vertex data and may be programmed totransform the vertex data from an object-based coordinate representationto a world space coordinate space or a normalized device coordinatespace.

A first instance of a primitive assembler 506 receives vertex attributesfrom the vertex processing unit 504. The primitive assembler 506readings stored vertex attributes as needed and constructs graphicsprimitives for processing by tessellation control processing unit 508.The graphics primitives include triangles, line segments, points,patches, and so forth, as supported by various graphics processingapplication programming interfaces (APIs).

The tessellation control processing unit 508 treats the input verticesas control points for a geometric patch. The control points aretransformed from an input representation from the patch (e.g., thepatch's bases) to a representation that is suitable for use in surfaceevaluation by the tessellation evaluation processing unit 512. Thetessellation control processing unit 508 can also compute tessellationfactors for edges of geometric patches. A tessellation factor applies toa single edge and quantifies a view-dependent level of detail associatedwith the edge. A tessellation unit 510 is configured to receive thetessellation factors for edges of a patch and to tessellate the patchinto multiple geometric primitives such as line, triangle, orquadrilateral primitives, which are transmitted to a tessellationevaluation processing unit 512. The tessellation evaluation processingunit 512 operates on parameterized coordinates of the subdivided patchto generate a surface representation and vertex attributes for eachvertex associated with the geometric primitives.

A second instance of a primitive assembler 514 receives vertexattributes from the tessellation evaluation processing unit 512, readingstored vertex attributes as needed, and constructs graphics primitivesfor processing by the geometry processing unit 516. The geometryprocessing unit 516 is a programmable execution unit that executesgeometry shader programs to transform graphics primitives received fromprimitive assembler 514 as specified by the geometry shader programs.The geometry processing unit 516 may be programmed to subdivide thegraphics primitives into one or more new graphics primitives andcalculate parameters used to rasterize the new graphics primitives.

The geometry processing unit 516 may be able to add or delete elementsin the geometry stream. The geometry processing unit 516 outputs theparameters and vertices specifying new graphics primitives to primitiveassembler 518. The primitive assembler 518 receives the parameters andvertices from the geometry processing unit 516 and constructs graphicsprimitives for processing by a viewport scale, cull, and clip unit 520.The geometry processing unit 516 reads data that is stored in parallelprocessor memory or system memory for use in processing the geometrydata. The viewport scale, cull, and clip unit 520 performs clipping,culling, and viewport scaling and outputs processed graphics primitivesto a rasterizer 522.

The rasterizer 522 can perform depth culling and other depth-basedoptimizations. The rasterizer 522 also performs scan conversion on thenew graphics primitives to generate fragments and output those fragmentsand associated coverage data to the fragment/pixel processing unit 524.The fragment/pixel processing unit 524 is a programmable execution unitthat is configured to execute fragment shader programs or pixel shaderprograms. The fragment/pixel processing unit 524 transforming fragmentsor pixels received from rasterizer 522, as specified by the fragment orpixel shader programs. For example, the fragment/pixel processing unit524 may be programmed to perform operations included but not limited totexture mapping, shading, blending, texture correction and perspectivecorrection to produce shaded fragments or pixels that are output to araster operations unit 526. The fragment/pixel processing unit 524 canread data that is stored in either the parallel processor memory or thesystem memory for use when processing the fragment data. Fragment orpixel shader programs may be configured to shade at sample, pixel, tile,or other granularities depending on the sampling rate configured for theprocessing units.

The raster operations unit 526 is a processing unit that performs rasteroperations including, but not limited to stencil, z-test, blending, andthe like, and outputs pixel data as processed graphics data to be storedin graphics memory (e.g., parallel processor memory 222 as in FIG. 2A,and/or system memory 104 as in FIG. 1), to be displayed on the one ormore display device(s) 110 or for further processing by one of the oneor more processor(s) 102 or parallel processor(s) 112. The rasteroperations unit 526 may be configured to compress z or color data thatis written to memory and decompress z or color data that is read frommemory.

Machine Learning Overview

The architecture described above can be applied to perform training andinference operations using machine learning models. Machine learning hasbeen successful at solving many kinds of tasks. The computations thatarise when training and using machine learning algorithms (e.g., neuralnetworks) lend themselves naturally to efficient parallelimplementations. Accordingly, parallel processors such asgeneral-purpose graphic processing units (GPGPUs) have played asignificant role in the practical implementation of deep neuralnetworks. Parallel graphics processors with single instruction, multiplethread (SIMI) architectures are designed to maximize the amount ofparallel processing in the graphics pipeline. In an SIMT architecture,groups of parallel threads attempt to execute program instructionssynchronously together as often as possible to increase processingefficiency. The efficiency provided by parallel machine learningalgorithm implementations allows the use of high capacity networks andenables those networks to be trained on larger datasets.

A machine learning algorithm is an algorithm that can learn based on aset of data. For example, machine learning algorithms can be designed tomodel high-level abstractions within a data set. For example, imagerecognition algorithms can be used to determine which of severalcategories to which a given input belong; regression algorithms canoutput a numerical value given an input; and pattern recognitionalgorithms can be used to generate translated text or perform text tospeech and/or speech recognition.

An exemplary type of machine learning algorithm is a neural network.There are many types of neural networks; a simple type of neural networkis a feedforward network. A feedforward network may be implemented as anacyclic graph in which the nodes are arranged in layers. Typically, afeedforward network topology includes an input layer and an output layerthat are separated by at least one hidden layer. The hidden layertransforms input received by the input layer into a representation thatis useful for generating output in the output layer. The network nodesare fully connected via edges to the nodes in adjacent layers, but thereare no edges between nodes within each layer. Data received at the nodesof an input layer of a feedforward network are propagated (i.e., “fedforward”) to the nodes of the output layer via an activation functionthat calculates the states of the nodes of each successive layer in thenetwork based on coefficients (“weights”) respectively associated witheach of the edges connecting the layers. Depending on the specific modelbeing represented by the algorithm being executed, the output from theneural network algorithm can take various forms.

Before a machine learning algorithm can be used to model a particularproblem, the algorithm is trained using a training data set. Training aneural network involves selecting a network topology, using a set oftraining data representing a problem being modeled by the network, andadjusting the weights until the network model performs with a minimalerror for all instances of the training data set. For example, during asupervised learning training process for a neural network, the outputproduced by the network in response to the input representing aninstance in a training data set is compared to the “correct” labeledoutput for that instance, an error signal representing the differencebetween the output and the labeled output is calculated, and the weightsassociated with the connections are adjusted to minimize that error asthe error signal is backward propagated through the layers of thenetwork. The network is considered “trained” when the errors for each ofthe outputs generated from the instances of the training data set areminimized.

The accuracy of a machine learning algorithm can be affectedsignificantly by the quality of the data set used to train thealgorithm. The training process can be computationally intensive and mayrequire a significant amount of time on a conventional general-purposeprocessor. Accordingly, parallel processing hardware is used to trainmany types of machine learning algorithms. This is particularly usefulfor optimizing the training of neural networks, as the computationsperformed in adjusting the coefficients in neural networks lendthemselves naturally to parallel implementations. Specifically, manymachine learning algorithms and software applications have been adaptedto make use of the parallel processing hardware within general-purposegraphics processing devices.

FIG. 6 is a generalized diagram of a machine learning software stack600. A machine learning application 602 is any logic that can beconfigured to train a neural network using a training dataset or to usea trained deep neural network to implement machine intelligence. Themachine learning application 602 can include training and inferencefunctionality for a neural network and/or specialized software that canbe used to train a neural network before deployment. The machinelearning application 602 can implement any type of machine intelligenceincluding but not limited to image recognition, mapping andlocalization, autonomous navigation, speech synthesis, medical imaging,or language translation. Example machine learning applications 602include, but are not limited to, voice-based virtual assistants, imageor facial recognition algorithms, autonomous navigation, and thesoftware tools that are used to train the machine learning models usedby the machine learning applications 602.

Hardware acceleration for the machine learning application 602 can beenabled via a machine learning framework 604. The machine learningframework 604 can provide a library of machine learning primitives.Machine learning primitives are basic operations that are commonlyperformed by machine learning algorithms. Without the machine learningframework 604, developers of machine learning algorithms would berequired to create and optimize the main computational logic associatedwith the machine learning algorithm, then re-optimize the computationallogic as new parallel processors are developed. Instead, the machinelearning application can be configured to perform the necessarycomputations using the primitives provided by the machine learningframework 604. Exemplary primitives include tensor convolutions,activation functions, and pooling, which are computational operationsthat are performed while training a convolutional neural network (CNN).The machine learning framework 604 can also provide primitives toimplement basic linear algebra subprograms performed by manymachine-learning algorithms, such as matrix and vector operations.Examples of a machine learning framework 604 include, but are notlimited to, TensorFlow, TensorRT, PyTorch, MXNet, Caffee, and otherhigh-level machine learning frameworks.

The machine learning framework 604 can process input data received fromthe machine learning application 602 and generate the appropriate inputto a compute framework 606. The compute framework 606 can abstract theunderlying instructions provided to the GPGPU driver 608 to enable themachine learning framework 604 to take advantage of hardwareacceleration via the GPGPU hardware 610 without requiring the machinelearning framework 604 to have intimate knowledge of the architecture ofthe GPGPU hardware 610. Additionally, the compute framework 606 canenable hardware acceleration for the machine learning framework 604across a variety of types and generations of the GPGPU hardware 610.Exemplary compute frameworks 606 include the CUDA compute framework andassociated machine learning libraries, such as the CUDA Deep NeuralNetwork (cuDNN) library. The machine learning software stack 600 canalso include communication libraries or frameworks to facilitatemulti-GPU and multi-node compute.

GPGPU Machine Learning Acceleration

FIG. 7 illustrates a general-purpose graphics processing unit 700, whichmay be the parallel processor 200 of FIG. 2A or the parallelprocessor(s) 112 of FIG. 1. The general-purpose processing unit (GPGPU)700 may be configured to provide support for hardware acceleration ofprimitives provided by a machine learning framework to accelerate theprocessing the type of computational workloads associated with trainingdeep neural networks. Additionally, the GPGPU 700 can be linked directlyto other instances of the GPGPU to create a multi-GPU cluster to improvetraining speed for particularly deep neural networks. Primitives arealso supported to accelerate inference operations for deployed neuralnetworks.

The GPGPU 700 includes a host interface 702 to enable a connection witha host processor. The host interface 702 may be a PCI Express interface.However, the host interface can also be a vendor specific communicationsinterface or communications fabric. The GPGPU 700 receives commands fromthe host processor and uses a global scheduler 704 to distributeexecution threads associated with those commands to a set of processingclusters 706A-706H. The processing clusters 706A-706H share a cachememory 708. The cache memory 708 can serve as a higher-level cache forcache memories within the processing clusters 706A-706H. The illustratedprocessing clusters 706A-706H may correspond with processing clusters214A-214N as in FIG. 2A.

The GPGPU 700 includes memory 714A-714B coupled with the processingclusters 706A-706H via a set of memory controllers 712A-712B. The memory714A-714B can include various types of memory devices including dynamicrandom-access memory (DRAM) or graphics random access memory, such assynchronous graphics random access memory (SGRAM), including graphicsdouble data rate (GDDR) memory. The memory 714A-714B may also include 3Dstacked memory, including but not limited to high bandwidth memory(HBM).

Each of the processing clusters 706A-706H may include a set of graphicsmultiprocessors, such as the graphics multiprocessor 234 of FIG. 2D,graphics multiprocessor 325 of FIG. 3A, graphics multiprocessor 350 ofFIG. 3B, or may include a multi-core group 365A-365N as in FIG. 3C. Thegraphics multiprocessors of the compute cluster include multiple typesof integer and floating-point logic units that can perform computationaloperations at a range of precisions including suited for machinelearning computations. For example, at least a subset of thefloating-point units in each of the processing clusters 706A-706H can beconfigured to perform 16-bit or 32-bit floating point operations, whilea different subset of the floating-point units can be configured toperform 64-bit floating point operations.

Multiple instances of the GPGPU 700 can be configured to operate as acompute cluster. The communication mechanism used by the compute clusterfor synchronization and data exchange varies across embodiments. Forexample, the multiple instances of the GPGPU 700 communicate over thehost interface 702. In one embodiment the GPGPU 700 includes an I/O hub709 that couples the GPGPU 700 with a GPU link 710 that enables a directconnection to other instances of the GPGPU. The GPU link 710 may becoupled to a dedicated GPU-to-GPU bridge that enables communication andsynchronization between multiple instances of the GPGPU 700. Optionally,the GPU link 710 couples with a high-speed interconnect to transmit andreceive data to other GPGPUs or parallel processors. The multipleinstances of the GPGPU 700 may be located in separate data processingsystems and communicate via a network device that is accessible via thehost interface 702. The GPU link 710 may be configured to enable aconnection to a host processor in addition to or as an alternative tothe host interface 702.

While the illustrated configuration of the GPGPU 700 can be configuredto train neural networks, an alternate configuration of the GPGPU 700can be configured for deployment within a high performance or low powerinferencing platform. In an inferencing configuration, the GPGPU 700includes fewer of the processing clusters 706A-706H relative to thetraining configuration. Additionally, memory technology associated withthe memory 714A-714B may differ between inferencing and trainingconfigurations. In one embodiment, the inferencing configuration of theGPGPU 700 can support inferencing specific instructions. For example, aninferencing configuration can provide support for one or more 8-bitinteger dot product instructions, which are commonly used duringinferencing operations for deployed neural networks.

FIG. 8 illustrates a multi-GPU computing system 800. The multi-GPUcomputing system 800 can include a processor 802 coupled to multipleGPGPUs 806A-806D via a host interface switch 804. The host interfaceswitch 804 may be a PCI express switch device that couples the processor802 to a PCI express bus over which the processor 802 can communicatewith the set of GPGPUs 806A-806D. Each of the multiple GPGPUs 806A-806Dcan be an instance of the GPGPU 700 of FIG. 7. The GPGPUs 806A-806D caninterconnect via a set of high-speed point to point GPU to GPU links816. The high-speed GPU to GPU links can connect to each of the GPGPUs806A-806D via a dedicated GPU link, such as the GPU link 710 as in FIG.7. The P2P GPU links 816 enable direct communication between each of theGPGPUs 806A-806D without requiring communication over the host interfacebus to which the processor 802 is connected. With GPU-to-GPU trafficdirected to the P2P GPU links, the host interface bus remains availablefor system memory access or to communicate with other instances of themulti-GPU computing system 800, for example, via one or more networkdevices. While in FIG. 8 the GPGPUs 806A-806D connect to the processor802 via the host interface switch 804, the processor 802 mayalternatively include direct support for the P2P GPU links 816 andconnect directly to the GPGPUs 806A-806D. In one embodiment the P2P GPUlink 816 enable the multi-GPU computing system 800 to operate as asingle logical GPU.

Machine Learning Neural Network Implementations

The computing architecture described herein can be configured to performthe types of parallel processing that is particularly suited fortraining and deploying neural networks for machine learning. A neuralnetwork can be generalized as a network of functions having a graphrelationship. As is well-known in the art, there are a variety of typesof neural network implementations used in machine learning. Oneexemplary type of neural network is the feedforward network, aspreviously described.

A second exemplary type of neural network is the Convolutional NeuralNetwork (CNN). A CNN is a specialized feedforward neural network forprocessing data having a known, grid-like topology, such as image data.Accordingly, CNNs are commonly used for compute vision and imagerecognition applications, but they also may be used for other types ofpattern recognition such as speech and language processing. The nodes inthe CNN input layer are organized into a set of “filters” (featuredetectors inspired by the receptive fields found in the retina), and theoutput of each set of filters is propagated to nodes in successivelayers of the network. The computations for a CNN include applying theconvolution mathematical operation to each filter to produce the outputof that filter. Convolution is a specialized kind of mathematicaloperation performed by two functions to produce a third function that isa modified version of one of the two original functions. Inconvolutional network terminology, the first function to the convolutioncan be referred to as the input, while the second function can bereferred to as the convolution kernel. The output may be referred to asthe feature map. For example, the input to a convolution layer can be amultidimensional array of data that defines the various color componentsof an input image. The convolution kernel can be a multidimensionalarray of parameters, where the parameters are adapted by the trainingprocess for the neural network.

Recurrent neural networks (RNNs) are a family of feedforward neuralnetworks that include feedback connections between layers. RNNs enablemodeling of sequential data by sharing parameter data across differentparts of the neural network. The architecture for an RNN includescycles. The cycles represent the influence of a present value of avariable on its own value at a future time, as at least a portion of theoutput data from the RNN is used as feedback for processing subsequentinput in a sequence. This feature makes RNNs particularly useful forlanguage processing due to the variable nature in which language datacan be composed.

The figures described below present exemplary feedforward, CNN, and RNNnetworks, as well as describe a general process for respectivelytraining and deploying each of those types of networks. It will beunderstood that these descriptions are exemplary and non-limiting as toany specific embodiment described herein and the concepts illustratedcan be applied generally to deep neural networks and machine learningtechniques in general.

The exemplary neural networks described above can be used to performdeep learning. Deep learning is machine learning using deep neuralnetworks. The deep neural networks used in deep learning are artificialneural networks composed of multiple hidden layers, as opposed toshallow neural networks that include only a single hidden layer. Deeperneural networks are generally more computationally intensive to train.However, the additional hidden layers of the network enable multisteppattern recognition that results in reduced output error relative toshallow machine learning techniques.

Deep neural networks used in deep learning typically include a front-endnetwork to perform feature recognition coupled to a back-end networkwhich represents a mathematical model that can perform operations (e.g.,object classification, speech recognition, etc.) based on the featurerepresentation provided to the model. Deep learning enables machinelearning to be performed without requiring hand crafted featureengineering to be performed for the model. Instead, deep neural networkscan learn features based on statistical structure or correlation withinthe input data. The learned features can be provided to a mathematicalmodel that can map detected features to an output. The mathematicalmodel used by the network is generally specialized for the specific taskto be performed, and different models will be used to perform differenttask.

Once the neural network is structured, a learning model can be appliedto the network to train the network to perform specific tasks. Thelearning model describes how to adjust the weights within the model toreduce the output error of the network. Backpropagation of errors is acommon method used to train neural networks. An input vector ispresented to the network for processing. The output of the network iscompared to the desired output using a loss function and an error valueis calculated for each of the neurons in the output layer. The errorvalues are then propagated backwards until each neuron has an associatederror value which roughly represents its contribution to the originaloutput. The network can then learn from those errors using an algorithm,such as the stochastic gradient descent algorithm, to update the weightsof the of the neural network.

FIG. 9A-9B illustrate an exemplary convolutional neural network. FIG. 9Aillustrates various layers within a CNN. As shown in FIG. 9A, anexemplary CNN used to model image processing can receive input 902describing the red, green, and blue (RGB) components of an input image.The input 902 can be processed by multiple convolutional layers (e.g.,convolutional layer 904, convolutional layer 906). The output from themultiple convolutional layers may optionally be processed by a set offully connected layers 908. Neurons in a fully connected layer have fullconnections to all activations in the previous layer, as previouslydescribed for a feedforward network. The output from the fully connectedlayers 908 can be used to generate an output result from the network.The activations within the fully connected layers 908 can be computedusing matrix multiplication instead of convolution. Not all CNNimplementations make use of fully connected layers 908. For example, insome implementations the convolutional layer 906 can generate output forthe CNN.

The convolutional layers are sparsely connected, which differs fromtraditional neural network configuration found in the fully connectedlayers 908. Traditional neural network layers are fully connected, suchthat every output unit interacts with every input unit. However, theconvolutional layers are sparsely connected because the output of theconvolution of a field is input (instead of the respective state valueof each of the nodes in the field) to the nodes of the subsequent layer,as illustrated. The kernels associated with the convolutional layersperform convolution operations, the output of which is sent to the nextlayer. The dimensionality reduction performed within the convolutionallayers is one aspect that enables the CNN to scale to process largeimages.

FIG. 9B illustrates exemplary computation stages within a convolutionallayer of a CNN. Input to a convolutional layer 912 of a CNN can beprocessed in three stages of a convolutional layer 914. The three stagescan include a convolution stage 916, a detector stage 918, and a poolingstage 920. The convolution layer 914 can then output data to asuccessive convolutional layer. The final convolutional layer of thenetwork can generate output feature map data or provide input to a fullyconnected layer, for example, to generate a classification value for theinput to the CNN.

In the convolution stage 916 performs several convolutions in parallelto produce a set of linear activations. The convolution stage 916 caninclude an affine transformation, which is any transformation that canbe specified as a linear transformation plus a translation. Affinetransformations include rotations, translations, scaling, andcombinations of these transformations. The convolution stage computesthe output of functions (e.g., neurons) that are connected to specificregions in the input, which can be determined as the local regionassociated with the neuron. The neurons compute a dot product betweenthe weights of the neurons and the region in the local input to whichthe neurons are connected. The output from the convolution stage 916defines a set of linear activations that are processed by successivestages of the convolutional layer 914.

The linear activations can be processed by a detector stage 918. In thedetector stage 918, each linear activation is processed by a non-linearactivation function. The non-linear activation function increases thenonlinear properties of the overall network without affecting thereceptive fields of the convolution layer. Several types of non-linearactivation functions may be used. One particular type is the rectifiedlinear unit (ReLU), which uses an activation function defined asƒ(x)=max (0,x), such that the activation is thresholded at zero.

The pooling stage 920 uses a pooling function that replaces the outputof the convolutional layer 906 with a summary statistic of the nearbyoutputs. The pooling function can be used to introduce translationinvariance into the neural network, such that small translations to theinput do not change the pooled outputs. Invariance to local translationcan be useful in scenarios where the presence of a feature in the inputdata is more important than the precise location of the feature. Varioustypes of pooling functions can be used during the pooling stage 920,including max pooling, average pooling, and l2-norm pooling.Additionally, some CNN implementations do not include a pooling stage.Instead, such implementations substitute and additional convolutionstage having an increased stride relative to previous convolutionstages.

The output from the convolutional layer 914 can then be processed by thenext layer 922. The next layer 922 can be an additional convolutionallayer or one of the fully connected layers 908. For example, the firstconvolutional layer 904 of FIG. 9A can output to the secondconvolutional layer 906, while the second convolutional layer can outputto a first layer of the fully connected layers 908.

FIG. 10 illustrates an exemplary recurrent neural network 1000. In arecurrent neural network (RNN), the previous state of the networkinfluences the output of the current state of the network. RNNs can bebuilt in a variety of ways using a variety of functions. The use of RNNsgenerally revolves around using mathematical models to predict thefuture based on a prior sequence of inputs. For example, an RNN may beused to perform statistical language modeling to predict an upcomingword given a previous sequence of words. The illustrated RNN 1000 can bedescribed has having an input layer 1002 that receives an input vector,hidden layers 1004 to implement a recurrent function, a feedbackmechanism 1005 to enable a ‘memory’ of previous states, and an outputlayer 1006 to output a result. The RNN 1000 operates based ontime-steps. The state of the RNN at a given time step is influencedbased on the previous time step via the feedback mechanism 1005. For agiven time step, the state of the hidden layers 1004 is defined by theprevious state and the input at the current time step. An initial input(x₁) at a first time step can be processed by the hidden layer 1004. Asecond input (x₂) can be processed by the hidden layer 1004 using stateinformation that is determined during the processing of the initialinput (x₁). A given state can be computed as s_(t)=ƒ(Ux_(t)+Ws_(t−1)),where U and W are parameter matrices. The function ƒ is generally anonlinearity, such as the hyperbolic tangent function (Tan h) or avariant of the rectifier function ƒ(x)=max(0,x). However, the specificmathematical function used in the hidden layers 1004 can vary dependingon the specific implementation details of the RNN 1000.

In addition to the basic CNN and RNN networks described, accelerationfor variations on those networks may be enabled. One example RNN variantis the long short term memory (LSTM) RNN. LSTM RNNs are capable oflearning long-term dependencies that may be necessary for processinglonger sequences of language. A variant on the CNN is a convolutionaldeep belief network, which has a structure similar to a CNN and istrained in a manner similar to a deep belief network. A deep beliefnetwork (DBN) is a generative neural network that is composed ofmultiple layers of stochastic (random) variables. DBNs can be trainedlayer-by-layer using greedy unsupervised learning. The learned weightsof the DBN can then be used to provide pre-train neural networks bydetermining an optimal initial set of weights for the neural network. Infurther embodiments, acceleration for reinforcement learning is enabled.In reinforcement learning, an artificial agent learn by interacting withits environment. The agent is configured to optimize certain objectivesto maximize cumulative rewards.

FIG. 11 illustrates training and deployment of a deep neural network.Once a given network has been structured for a task the neural networkis trained using a training dataset 1102. Various training frameworks1104 have been developed to enable hardware acceleration of the trainingprocess. For example, the machine learning framework 604 of FIG. 6 maybe configured as a training framework 604. The training framework 604can hook into an untrained neural network 1106 and enable the untrainedneural net to be trained using the parallel processing resourcesdescribed herein to generate a trained neural net 1108.

To start the training process the initial weights may be chosen randomlyor by pre-training using a deep belief network. The training cycle thenbe performed in either a supervised or unsupervised manner.

Supervised learning is a learning method in which training is performedas a mediated operation, such as when the training dataset 1102 includesinput paired with the desired output for the input, or where thetraining dataset includes input having known output and the output ofthe neural network is manually graded. The network processes the inputsand compares the resulting outputs against a set of expected or desiredoutputs. Errors are then propagated back through the system. Thetraining framework 1104 can adjust to adjust the weights that controlthe untrained neural network 1106. The training framework 1104 canprovide tools to monitor how well the untrained neural network 1106 isconverging towards a model suitable to generating correct answers basedon known input data. The training process occurs repeatedly as theweights of the network are adjusted to refine the output generated bythe neural network. The training process can continue until the neuralnetwork reaches a statistically desired accuracy associated with atrained neural net 1108. The trained neural network 1108 can then bedeployed to implement any number of machine learning operations togenerate an inference result 1114 based on input of new data 1112.

Unsupervised learning is a learning method in which the network attemptsto train itself using unlabeled data. Thus, for unsupervised learningthe training dataset 1102 will include input data without any associatedoutput data. The untrained neural network 1106 can learn groupingswithin the unlabeled input and can determine how individual inputs arerelated to the overall dataset. Unsupervised training can be used togenerate a self-organizing map, which is a type of trained neuralnetwork 1108 capable of performing operations useful in reducing thedimensionality of data. Unsupervised training can also be used toperform anomaly detection, which allows the identification of datapoints in an input dataset that deviate from the normal patterns of thedata.

Variations on supervised and unsupervised training may also be employed.Semi-supervised learning is a technique in which in the training dataset1102 includes a mix of labeled and unlabeled data of the samedistribution. Incremental learning is a variant of supervised learningin which input data is continuously used to further train the model.Incremental learning enables the trained neural network 1108 to adapt tothe new data 1112 without forgetting the knowledge instilled within thenetwork during initial training.

Whether supervised or unsupervised, the training process forparticularly deep neural networks may be too computationally intensivefor a single compute node. Instead of using a single compute node, adistributed network of computational nodes can be used to accelerate thetraining process.

FIG. 12A is a block diagram illustrating distributed learning.Distributed learning is a training model that uses multiple distributedcomputing nodes to perform supervised or unsupervised training of aneural network. The distributed computational nodes can each include oneor more host processors and one or more of the general-purposeprocessing nodes, such as the highly parallel general-purpose graphicsprocessing unit 700 as in FIG. 7. As illustrated, distributed learningcan be performed with model parallelism 1202, data parallelism 1204, ora combination of model and data parallelism 1206.

In model parallelism 1202, different computational nodes in adistributed system can perform training computations for different partsof a single network. For example, each layer of a neural network can betrained by a different processing node of the distributed system. Thebenefits of model parallelism include the ability to scale toparticularly large models. Splitting the computations associated withdifferent layers of the neural network enables the training of verylarge neural networks in which the weights of all layers would not fitinto the memory of a single computational node. In some instances, modelparallelism can be particularly useful in performing unsupervisedtraining of large neural networks.

In data parallelism 1204, the different nodes of the distributed networkhave a complete instance of the model and each node receives a differentportion of the data. The results from the different nodes are thencombined. While different approaches to data parallelism are possible,data parallel training approaches all require a technique of combiningresults and synchronizing the model parameters between each node.Exemplary approaches to combining data include parameter averaging andupdate based data parallelism. Parameter averaging trains each node on asubset of the training data and sets the global parameters (e.g.,weights, biases) to the average of the parameters from each node.Parameter averaging uses a central parameter server that maintains theparameter data. Update based data parallelism is similar to parameteraveraging except that instead of transferring parameters from the nodesto the parameter server, the updates to the model are transferred.Additionally, update based data parallelism can be performed in adecentralized manner, where the updates are compressed and transferredbetween nodes.

Combined model and data parallelism 1206 can be implemented, forexample, in a distributed system in which each computational nodeincludes multiple GPUs. Each node can have a complete instance of themodel with separate GPUs within each node are used to train differentportions of the model.

Distributed training has increased overhead relative to training on asingle machine. However, the parallel processors and GPGPUs describedherein can each implement various techniques to reduce the overhead ofdistributed training, including techniques to enable high bandwidthGPU-to-GPU data transfer and accelerated remote data synchronization.

FIG. 12B is a block diagram illustrating a programmable networkinterface 1210 and data processing unit. The programmable networkinterface 1210 is a programmable network engine that can be used toaccelerate network-based compute tasks within a distributed environment.The programmable network interface 1210 can couple with a host systemvia host interface 1270. The programmable network interface 1210 can beused to accelerate network or storage operations for CPUs or GPUs of thehost system. The host system can be, for example, a node of adistributed learning system used to perform distributed training, forexample, as shown in FIG. 12A. The host system can also be a data centernode within a data center.

In one embodiment, access to remote storage containing model data can beaccelerated by the programmable network interface 1210. For example, theprogrammable network interface 1210 can be configured to present remotestorage devices as local storage devices to the host system. Theprogrammable network interface 1210 can also accelerate remote directmemory access (RDMA) operations performed between GPUs of the hostsystem with GPUs of remote systems. In one embodiment, the programmablenetwork interface 1210 can enable storage functionality such as, but notlimited to NVME-oF. The programmable network interface 1210 can alsoaccelerate encryption, data integrity, compression, and other operationsfor remote storage on behalf of the host system, allowing remote storageto approach the latencies of storage devices that are directly attachedto the host system.

The programmable network interface 1210 can also perform resourceallocation and management on behalf of the host system. Storage securityoperations can be offloaded to the programmable network interface 1210and performed in concert with the allocation and management of remotestorage resources. Network-based operations to manage access to theremote storage that would otherwise by performed by a processor of thehost system can instead be performed by the programmable networkinterface 1210.

In one embodiment, network and/or data security operations can beoffloaded from the host system to the programmable network interface1210. Data center security policies for a data center node can behandled by the programmable network interface 1210 instead of theprocessors of the host system. For example, the programmable networkinterface 1210 can detect and mitigate against an attemptednetwork-based attack (e.g., DDoS) on the host system, preventing theattack from compromising the availability of the host system.

The programmable network interface 1210 can include a system on a chip(SoC 1220) that executes an operating system via multiple processorcores 1222. The processor cores 1222 can include general-purposeprocessor (e.g., CPU) cores. In one embodiment the processor cores 1222can also include one or more GPU cores. The SoC 1220 can executeinstructions stored in a memory device 1240. A storage device 1250 canstore local operating system data. The storage device 1250 and memorydevice 1240 can also be used to cache remote data for the host system.Network ports 1260A-1260B enable a connection to a network or fabric andfacilitate network access for the SoC 1220 and, via the host interface1270, for the host system. The programmable network interface 1210 canalso include an I/O interface 1275, such as a USB interface. The I/Ointerface 1275 can be used to couple external devices to theprogrammable network interface 1210 or as a debug interface. Theprogrammable network interface 1210 also includes a management interface1230 that enables software on the host device to manage and configurethe programmable network interface 1210 and/or SoC 1220. In oneembodiment the programmable network interface 1210 may also include oneor more accelerators or GPUs 1245 to accept offload of parallel computetasks from the SoC 1220, host system, or remote systems coupled via thenetwork ports 1260A-1260B.

Exemplary Machine Learning Applications

Machine learning can be applied to solve a variety of technologicalproblems, including but not limited to computer vision, autonomousdriving and navigation, speech recognition, and language processing.Computer vision has traditionally been one of the most active researchareas for machine learning applications. Applications of computer visionrange from reproducing human visual abilities, such as recognizingfaces, to creating new categories of visual abilities. For example,computer vision applications can be configured to recognize sound wavesfrom the vibrations induced in objects visible in a video. Parallelprocessor accelerated machine learning enables computer visionapplications to be trained using significantly larger training datasetthan previously feasible and enables inferencing systems to be deployedusing low power parallel processors.

Parallel processor accelerated machine learning has autonomous drivingapplications including lane and road sign recognition, obstacleavoidance, navigation, and driving control. Accelerated machine learningtechniques can be used to train driving models based on datasets thatdefine the appropriate responses to specific training input. Theparallel processors described herein can enable rapid training of theincreasingly complex neural networks used for autonomous drivingsolutions and enables the deployment of low power inferencing processorsin a mobile platform suitable for integration into autonomous vehicles.

Parallel processor accelerated deep neural networks have enabled machinelearning approaches to automatic speech recognition (ASR). ASR includesthe creation of a function that computes the most probable linguisticsequence given an input acoustic sequence. Accelerated machine learningusing deep neural networks have enabled the replacement of the hiddenMarkov models (HMMs) and Gaussian mixture models (GMMs) previously usedfor ASR.

Parallel processor accelerated machine learning can also be used toaccelerate natural language processing. Automatic learning procedurescan make use of statistical inference algorithms to produce models thatare robust to erroneous or unfamiliar input. Exemplary natural languageprocessor applications include automatic machine translation betweenhuman languages.

The parallel processing platforms used for machine learning can bedivided into training platforms and deployment platforms. Trainingplatforms are generally highly parallel and include optimizations toaccelerate multi-GPU single node training and multi-node, multi-GPUtraining. Exemplary parallel processors suited for training include thegeneral-purpose graphics processing unit 700 of FIG. 7 and the multi-GPUcomputing system 800 of FIG. 8. On the contrary, deployed machinelearning platforms generally include lower power parallel processorssuitable for use in products such as cameras, autonomous robots, andautonomous vehicles.

Additionally, machine learning techniques can be applied to accelerateor enhance graphics processing activities. For example, a machinelearning model can be trained to recognize output generated by a GPUaccelerated application and generate an upscaled version of that output.Such techniques can be applied to accelerate the generation of highresolution images for a gaming application. Various other graphicspipeline activities can benefit from the use of machine learning. Forexample, machine learning models can be trained to perform tessellationoperations on geometry data to increase the complexity of geometricmodels, allowing fine-detailed geometry to be automatically generatedfrom geometry of relatively lower detail.

FIG. 13 illustrates an exemplary inferencing system on a chip (SOC) 1300suitable for performing inferencing using a trained model. The SOC 1300can integrate processing components including a media processor 1302, avision processor 1304, a GPGPU 1306 and a multi-core processor 1308. TheGPGPU 1306 may be a GPGPU as described herein, such as the GPGPU 700,and the multi-core processor 1308 may be a multi-core processordescribed herein, such as the multi-core processors 405-406. The SOC1300 can additionally include on-chip memory 1305 that can enable ashared on-chip data pool that is accessible by each of the processingcomponents. The processing components can be optimized for low poweroperation to enable deployment to a variety of machine learningplatforms, including autonomous vehicles and autonomous robots. Forexample, one implementation of the SOC 1300 can be used as a portion ofthe main control system for an autonomous vehicle. Where the SOC 1300 isconfigured for use in autonomous vehicles the SOC is designed andconfigured for compliance with the relevant functional safety standardsof the deployment jurisdiction.

During operation, the media processor 1302 and vision processor 1304 canwork in concert to accelerate computer vision operations. The mediaprocessor 1302 can enable low latency decode of multiple high-resolution(e.g., 4K, 8K) video streams. The decoded video streams can be writtento a buffer in the on-chip memory 1305. The vision processor 1304 canthen parse the decoded video and perform preliminary processingoperations on the frames of the decoded video in preparation ofprocessing the frames using a trained image recognition model. Forexample, the vision processor 1304 can accelerate convolution operationsfor a CNN that is used to perform image recognition on thehigh-resolution video data, while back end model computations areperformed by the GPGPU 1306.

The multi-core processor 1308 can include control logic to assist withsequencing and synchronization of data transfers and shared memoryoperations performed by the media processor 1302 and the visionprocessor 1304. The multi-core processor 1308 can also function as anapplication processor to execute software applications that can make useof the inferencing compute capability of the GPGPU 1306. For example, atleast a portion of the navigation and driving logic can be implementedin software executing on the multi-core processor 1308. Such softwarecan directly issue computational workloads to the GPGPU 1306 or thecomputational workloads can be issued to the multi-core processor 1308,which can offload at least a portion of those operations to the GPGPU1306.

The GPGPU 1306 can include compute clusters such as a low powerconfiguration of the processing clusters 706A-706H withingeneral-purpose graphics processing unit 700. The compute clusterswithin the GPGPU 1306 can support instruction that are specificallyoptimized to perform inferencing computations on a trained neuralnetwork. For example, the GPGPU 1306 can support instructions to performlow precision computations such as 8-bit and 4-bit integer vectoroperations.

Additional System Overview

FIG. 14 is a block diagram of a processing system 1400. The elements ofFIG. 14 having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such. System 1400 may be usedin a single processor desktop system, a multiprocessor workstationsystem, or a server system having a large number of processors 1402 orprocessor cores 1407. The system 1400 may be a processing platformincorporated within a system-on-a-chip (SoC) integrated circuit for usein mobile, handheld, or embedded devices such as withinInternet-of-things (IoT) devices with wired or wireless connectivity toa local or wide area network.

The system 1400 may be a processing system having components thatcorrespond with those of FIG. 1. For example, in differentconfigurations, processor(s) 1402 or processor core(s) 1407 maycorrespond with processor(s) 102 of FIG. 1. Graphics processor(s) 1408may correspond with parallel processor(s) 112 of FIG. 1. Externalgraphics processor 1418 may be one of the add-in device(s) 120 of FIG.1.

The system 1400 can include, couple with, or be integrated within: aserver-based gaming platform; a game console, including a game and mediaconsole; a mobile gaming console, a handheld game console, or an onlinegame console. The system 1400 may be part of a mobile phone, smartphone, tablet computing device or mobile Internet-connected device suchas a laptop with low internal storage capacity. Processing system 1400can also include, couple with, or be integrated within: a wearabledevice, such as a smart watch wearable device; smart eyewear or clothingenhanced with augmented reality (AR) or virtual reality (VR) features toprovide visual, audio or tactile outputs to supplement real worldvisual, audio or tactile experiences or otherwise provide text, audio,graphics, video, holographic images or video, or tactile feedback; otheraugmented reality (AR) device; or other virtual reality (VR) device. Theprocessing system 1400 may include or be part of a television or set topbox device. The system 1400 can include, couple with, or be integratedwithin a self-driving vehicle such as a bus, tractor trailer, car, motoror electric power cycle, plane or glider (or any combination thereof).The self-driving vehicle may use system 1400 to process the environmentsensed around the vehicle.

The one or more processors 1402 may include one or more processor cores1407 to process instructions which, when executed, perform operationsfor system or user software. The least one of the one or more processorcores 1407 may be configured to process a specific instruction set 1409.The instruction set 1409 may facilitate Complex Instruction SetComputing (CISC), Reduced Instruction Set Computing (RISC), or computingvia a Very Long Instruction Word (VLIW). One or more processor cores1407 may process a different instruction set 1409, which may includeinstructions to facilitate the emulation of other instruction sets.Processor core 1407 may also include other processing devices, such as aDigital Signal Processor (DSP).

The processor 1402 may include cache memory 1404. Depending on thearchitecture, the processor 1402 can have a single internal cache ormultiple levels of internal cache. In some embodiments, the cache memoryis shared among various components of the processor 1402. In someembodiments, the processor 1402 also uses an external cache (e.g., aLevel-3 (L3) cache or Last Level Cache (LLC)) (not shown), which may beshared among processor cores 1407 using known cache coherencytechniques. A register file 1406 can be additionally included inprocessor 1402 and may include different types of registers for storingdifferent types of data (e.g., integer registers, floating pointregisters, status registers, and an instruction pointer register). Someregisters may be general-purpose registers, while other registers may bespecific to the design of the processor 1402.

The one or more processor(s) 1402 may be coupled with one or moreinterface bus(es) 1410 to transmit communication signals such asaddress, data, or control signals between processor 1402 and othercomponents in the system 1400. The interface bus 1410, in one of theseembodiments, can be a processor bus, such as a version of the DirectMedia Interface (DMI) bus. However, processor busses are not limited tothe DMI bus, and may include one or more Peripheral ComponentInterconnect buses (e.g., PCI, PCI express), memory busses, or othertypes of interface busses. For example, the processor(s) 1402 mayinclude an integrated memory controller 1416 and a platform controllerhub 1430. The memory controller 1416 facilitates communication between amemory device and other components of the system 1400, while theplatform controller hub (PCH) 1430 provides connections to I/O devicesvia a local I/O bus.

The memory device 1420 can be a dynamic random-access memory (DRAM)device, a static random-access memory (SRAM) device, flash memorydevice, phase-change memory device, or some other memory device havingsuitable performance to serve as process memory. The memory device 1420can, for example, operate as system memory for the system 1400, to storedata 1422 and instructions 1421 for use when the one or more processors1402 executes an application or process. Memory controller 1416 alsocouples with an optional external graphics processor 1418, which maycommunicate with the one or more graphics processors 1408 in processors1402 to perform graphics and media operations. In some embodiments,graphics, media, and or compute operations may be assisted by anaccelerator 1412 which is a coprocessor that can be configured toperform a specialized set of graphics, media, or compute operations. Forexample, the accelerator 1412 may be a matrix multiplication acceleratorused to optimize machine learning or compute operations. The accelerator1412 can be a ray-tracing accelerator that can be used to performray-tracing operations in concert with the graphics processor 1408. Inone embodiment, an external accelerator 1419 may be used in place of orin concert with the accelerator 1412.

A display device 1411 may be provided that can connect to theprocessor(s) 1402. The display device 1411 can be one or more of aninternal display device, as in a mobile electronic device or a laptopdevice or an external display device attached via a display interface(e.g., DisplayPort, etc.). The display device 1411 can be a head mounteddisplay (HMD) such as a stereoscopic display device for use in virtualreality (VR) applications or augmented reality (AR) applications.

The platform controller hub 1430 may enable peripherals to connect tomemory device 1420 and processor 1402 via a high-speed I/O bus. The I/Operipherals include, but are not limited to, an audio controller 1446, anetwork controller 1434, a firmware interface 1428, a wirelesstransceiver 1426, touch sensors 1425, a data storage device 1424 (e.g.,non-volatile memory, volatile memory, hard disk drive, flash memory,NAND, 3D NAND, 3D XPoint/Optane, etc.). The data storage device 1424 canconnect via a storage interface (e.g., SATA) or via a peripheral bus,such as a Peripheral Component Interconnect bus (e.g., PCI, PCIexpress). The touch sensors 1425 can include touch screen sensors,pressure sensors, or fingerprint sensors. The wireless transceiver 1426can be a Wi-Fi transceiver, a Bluetooth transceiver, or a mobile networktransceiver such as a 3G, 4G, 5G, or Long-Term Evolution (LTE)transceiver. The firmware interface 1428 enables communication withsystem firmware, and can be, for example, a unified extensible firmwareinterface (UEFI). The network controller 1434 can enable a networkconnection to a wired network. In some embodiments, a high-performancenetwork controller (not shown) couples with the interface bus 1410. Theaudio controller 1446 may be a multi-channel high definition audiocontroller. In some of these embodiments the system 1400 includes anoptional legacy I/O controller 1440 for coupling legacy (e.g., PersonalSystem 2 (PS/2)) devices to the system. The platform controller hub 1430can also connect to one or more Universal Serial Bus (USB) controllers1442 connect input devices, such as keyboard and mouse 1443combinations, a camera 1444, or other USB input devices.

It will be appreciated that the system 1400 shown is exemplary and notlimiting, as other types of data processing systems that are differentlyconfigured may also be used. For example, an instance of the memorycontroller 1416 and platform controller hub 1430 may be integrated intoa discrete external graphics processor, such as the external graphicsprocessor 1418. The platform controller hub 1430 and/or memorycontroller 1416 may be external to the one or more processor(s) 1402.For example, the system 1400 can include an external memory controller1416 and platform controller hub 1430, which may be configured as amemory controller hub and peripheral controller hub within a systemchipset that is in communication with the processor(s) 1402.

For example, circuit boards (“sleds”) can be used on which componentssuch as CPUs, memory, and other components are placed are designed forincreased thermal performance. Processing components such as theprocessors may be located on a top side of a sled while near memory,such as DIMMs, are located on a bottom side of the sled. As a result ofthe enhanced airflow provided by this design, the components may operateat higher frequencies and power levels than in typical systems, therebyincreasing performance. Furthermore, the sleds are configured to blindlymate with power and data communication cables in a rack, therebyenhancing their ability to be quickly removed, upgraded, reinstalled,and/or replaced. Similarly, individual components located on the sleds,such as processors, accelerators, memory, and data storage drives, areconfigured to be easily upgraded due to their increased spacing fromeach other. In the illustrative embodiment, the components additionallyinclude hardware attestation features to prove their authenticity.

A data center can utilize a single network architecture (“fabric”) thatsupports multiple other network architectures including Ethernet andOmni-Path. The sleds can be coupled to switches via optical fibers,which provide higher bandwidth and lower latency than typical twistedpair cabling (e.g., Category 5, Category 5e, Category 6, etc.). Due tothe high bandwidth, low latency interconnections and networkarchitecture, the data center may, in use, pool resources, such asmemory, accelerators (e.g., GPUs, graphics accelerators, FPGAs, ASICs,neural network and/or artificial intelligence accelerators, etc.), anddata storage drives that are physically disaggregated, and provide themto compute resources (e.g., processors) on an as needed basis, enablingthe compute resources to access the pooled resources as if they werelocal.

A power supply or source can provide voltage and/or current to system1400 or any component or system described herein. In one example, thepower supply includes an AC to DC (alternating current to directcurrent) adapter to plug into a wall outlet. Such AC power can berenewable energy (e.g., solar power) power source. In one example, thepower source includes a DC power source, such as an external AC to DCconverter. A power source or power supply may also include wirelesscharging hardware to charge via proximity to a charging field. The powersource can include an internal battery, alternating current supply,motion-based power supply, solar power supply, or fuel cell source.

FIG. 15A-15C illustrate computing systems and graphics processors. Theelements of FIG. 15A-15C having the same or similar names as theelements of any other figure herein describe the same elements as in theother figures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such.

FIG. 15A is a block diagram of a processor 1500, which may be a variantof one of the processors 1402 and may be used in place of one of those.Therefore, the disclosure of any features in combination with theprocessor 1500 herein also discloses a corresponding combination withthe processor(s) 1402, but is not limited to such. The processor 1500may have one or more processor cores 1502A-1502N, an integrated memorycontroller 1514, and an integrated graphics processor 1508. Where anintegrated graphics processor 1508 is excluded, the system that includesthe processor will include a graphics processor device within a systemchipset or coupled via a system bus. Processor 1500 can includeadditional cores up to and including additional core 1502N representedby the dashed lined boxes. Each of processor cores 1502A-1502N includesone or more internal cache units 1504A-1504N. In some embodiments eachprocessor core 1502A-1502N also has access to one or more shared cacheunits 1506. The internal cache units 1504A-1504N and shared cache units1506 represent a cache memory hierarchy within the processor 1500. Thecache memory hierarchy may include at least one level of instruction anddata cache within each processor core and one or more levels of sharedmid-level cache, such as a Level 2 (L2), Level 3 (L3), Level 4 (L4), orother levels of cache, where the highest level of cache before externalmemory is classified as the LLC. In some embodiments, cache coherencylogic maintains coherency between the various cache units 1506 and1504A-1504N.

The processor 1500 may also include a set of one or more bus controllerunits 1516 and a system agent core 1510. The one or more bus controllerunits 1516 manage a set of peripheral buses, such as one or more PCI orPCI express busses. System agent core 1510 provides managementfunctionality for the various processor components. The system agentcore 1510 may include one or more integrated memory controllers 1514 tomanage access to various external memory devices (not shown).

For example, one or more of the processor cores 1502A-1502N may includesupport for simultaneous multi-threading. The system agent core 1510includes components for coordinating and operating cores 1502A-1502Nduring multi-threaded processing. System agent core 1510 mayadditionally include a power control unit (PCU), which includes logicand components to regulate the power state of processor cores1502A-1502N and graphics processor 1508.

The processor 1500 may additionally include graphics processor 1508 toexecute graphics processing operations. In some of these embodiments,the graphics processor 1508 couples with the set of shared cache units1506, and the system agent core 1510, including the one or moreintegrated memory controllers 1514. The system agent core 1510 may alsoinclude a display controller 1511 to drive graphics processor output toone or more coupled displays. The display controller 1511 may also be aseparate module coupled with the graphics processor via at least oneinterconnect, or may be integrated within the graphics processor 1508.

A ring-based interconnect unit 1512 may be used to couple the internalcomponents of the processor 1500. However, an alternative interconnectunit may be used, such as a point-to-point interconnect, a switchedinterconnect, or other techniques, including techniques well known inthe art. In some of these embodiments with a ring-based interconnect1512, the graphics processor 1508 couples with the ring-basedinterconnect 1512 via an I/O link 1513.

The exemplary I/O link 1513 represents at least one of multiplevarieties of I/O interconnects, including an on package I/O interconnectwhich facilitates communication between various processor components anda high-performance embedded memory module 1518, such as an eDRAM module.Optionally, each of the processor cores 1502A-1502N and graphicsprocessor 1508 can use embedded memory modules 1518 as a shared LastLevel Cache.

The processor cores 1502A-1502N may, for example, be homogenous coresexecuting the same instruction set architecture. Alternatively, theprocessor cores 1502A-1502N are heterogeneous in terms of instructionset architecture (ISA), where one or more of processor cores 1502A-1502Nexecute a first instruction set, while at least one of the other coresexecutes a subset of the first instruction set or a differentinstruction set. The processor cores 1502A-1502N may be heterogeneous interms of microarchitecture, where one or more cores having a relativelyhigher power consumption couple with one or more power cores having alower power consumption. As another example, the processor cores1502A-1502N are heterogeneous in terms of computational capability.Additionally, processor 1500 can be implemented on one or more chips oras an SoC integrated circuit having the illustrated components, inaddition to other components.

FIG. 15B is a block diagram of hardware logic of a graphics processorcore 1519, according to some embodiments described herein. The graphicsprocessor core 1519, sometimes referred to as a core slice, can be oneor multiple graphics cores within a modular graphics processor. Thegraphics processor core 1519 is exemplary of one graphics core slice,and a graphics processor as described herein may include multiplegraphics core slices based on target power and performance envelopes.Each graphics processor core 1519 can include a fixed function block1530 coupled with multiple sub-cores 1521A-1521F, also referred to assub-slices, that include modular blocks of general-purpose and fixedfunction logic.

The fixed function block 1530 may include a geometry/fixed functionpipeline 1531 that can be shared by all sub-cores in the graphicsprocessor core 1519, for example, in lower performance and/or lowerpower graphics processor implementations. The geometry/fixed functionpipeline 1531 may include a 3D fixed function pipeline (e.g., 3Dpipeline 1612 as in FIG. 16A described below) a video front-end unit, athread spawner and thread dispatcher, and a unified return buffermanager, which manages unified return buffers (e.g., unified returnbuffer 1718 in FIG. 17, as described below).

The fixed function block 1530 may also include a graphics SoC interface1532, a graphics microcontroller 1533, and a media pipeline 1534. Thegraphics SoC interface 1532 provides an interface between the graphicsprocessor core 1519 and other processor cores within a system on a chipintegrated circuit. The graphics microcontroller 1533 is a programmablesub-processor that is configurable to manage various functions of thegraphics processor core 1519, including thread dispatch, scheduling, andpre-emption. The media pipeline 1534 (e.g., media pipeline 1616 of FIG.16A and FIG. 17) includes logic to facilitate the decoding, encoding,pre-processing, and/or post-processing of multimedia data, includingimage and video data. The media pipeline 1534 implement media operationsvia requests to compute or sampling logic within the sub-cores1521-1521F.

The SoC interface 1532 may enable the graphics processor core 1519 tocommunicate with general-purpose application processor cores (e.g.,CPUs) and/or other components within an SoC, including memory hierarchyelements such as a shared last level cache memory, the system RAM,and/or embedded on-chip or on-package DRAM. The SoC interface 1532 canalso enable communication with fixed function devices within the SoC,such as camera imaging pipelines, and enables the use of and/orimplements global memory atomics that may be shared between the graphicsprocessor core 1519 and CPUs within the SoC. The SoC interface 1532 canalso implement power management controls for the graphics processor core1519 and enable an interface between a clock domain of the graphic core1519 and other clock domains within the SoC. Optionally, the SoCinterface 1532 enables receipt of command buffers from a commandstreamer and global thread dispatcher that are configured to providecommands and instructions to each of one or more graphics cores within agraphics processor. The commands and instructions can be dispatched tothe media pipeline 1534, when media operations are to be performed, or ageometry and fixed function pipeline (e.g., geometry and fixed functionpipeline 1531, geometry and fixed function pipeline 1537) when graphicsprocessing operations are to be performed.

The graphics microcontroller 1533 can be configured to perform variousscheduling and management tasks for the graphics processor core 1519. Inone configuration the graphics microcontroller 1533 can, for example,perform graphics and/or compute workload scheduling on the variousgraphics parallel engines within execution unit (EU) arrays 1522A-1522F,1524A-1524F within the sub-cores 1521A-1521F. In this workloadscheduling, host software executing on a CPU core of an SoC includingthe graphics processor core 1519 can submit workloads to one of multiplegraphic processor doorbells, which invokes a scheduling operation on theappropriate graphics engine. Scheduling operations include determiningwhich workload to run next, submitting a workload to a command streamer,pre-empting existing workloads running on an engine, monitoring progressof a workload, and notifying host software when a workload is complete.Optionally, the graphics microcontroller 1533 can also facilitatelow-power or idle states for the graphics processor core 1519, providingthe graphics processor core 1519 with the ability to save and restoreregisters within the graphics processor core 1519 across low-power statetransitions independently from the operating system and/or graphicsdriver software on the system.

The graphics processor core 1519 may have more than or fewer than theillustrated sub-cores 1521A-1521F, up to N modular sub-cores. For eachset of N sub-cores, the graphics processor core 1519 can also includeshared function logic 1535, shared and/or cache memory 1536, ageometry/fixed function pipeline 1537, as well as additional fixedfunction logic 1538 to accelerate various graphics and computeprocessing operations. The shared function logic 1535 can include logicunits associated with the shared function logic 1720 of FIG. 17 (e.g.,sampler, math, and/or inter-thread communication logic) that can beshared by each N sub-cores within the graphics processor core 1519. Theshared and/or cache memory 1536 can be a last-level cache for the set ofN sub-cores 1521A-1521F within the graphics processor core 1519, and canalso serve as shared memory that is accessible by multiple sub-cores.The geometry/fixed function pipeline 1537 can be included instead of thegeometry/fixed function pipeline 1531 within the fixed function block1530 and can include the same or similar logic units.

The graphics processor core 1519 may include additional fixed functionlogic 1538 that can include various fixed function acceleration logicfor use by the graphics processor core 1519. Optionally, the additionalfixed function logic 1538 includes an additional geometry pipeline foruse in position only shading. In position-only shading, two geometrypipelines exist, the full geometry pipeline within the geometry/fixedfunction pipeline 1538, 1531, and a cull pipeline, which is anadditional geometry pipeline which may be included within the additionalfixed function logic 1538. For example, the cull pipeline may be atrimmed down version of the full geometry pipeline. The full pipelineand the cull pipeline can execute different instances of the sameapplication, each instance having a separate context. Position onlyshading can hide long cull runs of discarded triangles, enabling shadingto be completed earlier in some instances. For example, the cullpipeline logic within the additional fixed function logic 1538 canexecute position shaders in parallel with the main application andgenerally generates critical results faster than the full pipeline, asthe cull pipeline fetches and shades only the position attribute of thevertices, without performing rasterization and rendering of the pixelsto the frame buffer. The cull pipeline can use the generated criticalresults to compute visibility information for all the triangles withoutregard to whether those triangles are culled. The full pipeline (whichin this instance may be referred to as a replay pipeline) can consumethe visibility information to skip the culled triangles to shade onlythe visible triangles that are finally passed to the rasterizationphase.

Optionally, the additional fixed function logic 1538 can also includemachine-learning acceleration logic, such as fixed function matrixmultiplication logic, for implementations including optimizations formachine learning training or inferencing.

Within each graphics sub-core 1521A-1521F a set of execution resourcesis included that may be used to perform graphics, media, and computeoperations in response to requests by graphics pipeline, media pipeline,or shader programs. The graphics sub-cores 1521A-1521F include multipleEU arrays 1522A-1522F, 1524A-1524F, thread dispatch and inter-threadcommunication (TD/IC) logic 1523A-1523F, a 3D (e.g., texture) sampler1525A-1525F, a media sampler 1526A-1526F, a shader processor1527A-1527F, and shared local memory (SLM) 1528A-1528F. The EU arrays1522A-1522F, 1524A-1524F each include multiple execution units, whichare general-purpose graphics processing units capable of performingfloating-point and integer/fixed-point logic operations in service of agraphics, media, or compute operation, including graphics, media, orcompute shader programs. The TD/IC logic 1523A-1523F performs localthread dispatch and thread control operations for the execution unitswithin a sub-core and facilitate communication between threads executingon the execution units of the sub-core. The 3D sampler 1525A-1525F canread texture or other 3D graphics related data into memory. The 3Dsampler can read texture data differently based on a configured samplestate and the texture format associated with a given texture. The mediasampler 1526A-1526F can perform similar read operations based on thetype and format associated with media data. For example, each graphicssub-core 1521A-1521F can alternately include a unified 3D and mediasampler. Threads executing on the execution units within each of thesub-cores 1521A-1521F can make use of shared local memory 1528A-1528Fwithin each sub-core, to enable threads executing within a thread groupto execute using a common pool of on-chip memory.

FIG. 15C is a block diagram of general-purpose graphics processing unit(GPGPU) 1570 that can be configured as a graphics processor, e.g. thegraphics processor 1508, and/or compute accelerator, according toembodiments described herein. The GPGPU 1570 can interconnect with hostprocessors (e.g., one or more CPU(s) 1546) and memory 1571, 1572 via oneor more system and/or memory busses. Memory 1571 may be system memorythat can be shared with the one or more CPU(s) 1546, while memory 1572is device memory that is dedicated to the GPGPU 1570. For example,components within the GPGPU 1570 and device memory 1572 may be mappedinto memory addresses that are accessible to the one or more CPU(s)1546. Access to memory 1571 and 1572 may be facilitated via a memorycontroller 1568. The memory controller 1568 may include an internaldirect memory access (DMA) controller 1569 or can include logic toperform operations that would otherwise be performed by a DMAcontroller.

The GPGPU 1570 includes multiple cache memories, including an L2 cache1553, L1 cache 1554, an instruction cache 1555, and shared memory 1556,at least a portion of which may also be partitioned as a cache memory.The GPGPU 1570 also includes multiple compute units 1560A-1560N. Eachcompute unit 1560A-1560N includes a set of vector registers 1561, scalarregisters 1562, vector logic units 1563, and scalar logic units 1564.The compute units 1560A-1560N can also include local shared memory 1565and a program counter 1566. The compute units 1560A-1560N can couplewith a constant cache 1567, which can be used to store constant data,which is data that will not change during the run of kernel or shaderprogram that executes on the GPGPU 1570. The constant cache 1567 may bea scalar data cache and cached data can be fetched directly into thescalar registers 1562.

During operation, the one or more CPU(s) 1546 can write commands intoregisters or memory in the GPGPU 1570 that has been mapped into anaccessible address space. The command processors 1557 can read thecommands from registers or memory and determine how those commands willbe processed within the GPGPU 1570. A thread dispatcher 1558 can then beused to dispatch threads to the compute units 1560A-1560N to performthose commands. Each compute unit 1560A-1560N can execute threadsindependently of the other compute units. Additionally, each computeunit 1560A-1560N can be independently configured for conditionalcomputation and can conditionally output the results of computation tomemory. The command processors 1557 can interrupt the one or more CPU(s)1546 when the submitted commands are complete.

FIG. 16A-16C illustrate block diagrams of additional graphics processorand compute accelerator architectures provided by embodiments describedherein, e.g. in accordance with FIG. 15A-15C. The elements of FIG.16A-16C having the same or similar names as the elements of any otherfigure herein describe the same elements as in the other figures, canoperate or function in a manner similar to that, can comprise the samecomponents, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 16A is a block diagram of a graphics processor 1600, which may be adiscrete graphics processing unit, or may be a graphics processorintegrated with a plurality of processing cores, or other semiconductordevices such as, but not limited to, memory devices or networkinterfaces. The graphics processor 1600 may be a variant of the graphicsprocessor 1508 and may be used in place of the graphics processor 1508.Therefore, the disclosure of any features in combination with thegraphics processor 1508 herein also discloses a correspondingcombination with the graphics processor 1600, but is not limited tosuch. The graphics processor may communicate via a memory mapped I/Ointerface to registers on the graphics processor and with commandsplaced into the processor memory. Graphics processor 1600 may include amemory interface 1614 to access memory. Memory interface 1614 can be aninterface to local memory, one or more internal caches, one or moreshared external caches, and/or to system memory.

Optionally, graphics processor 1600 also includes a display controller1602 to drive display output data to a display device 1618. Displaycontroller 1602 includes hardware for one or more overlay planes for thedisplay and composition of multiple layers of video or user interfaceelements. The display device 1618 can be an internal or external displaydevice. In one embodiment the display device 1618 is a head mounteddisplay device, such as a virtual reality (VR) display device or anaugmented reality (AR) display device. Graphics processor 1600 mayinclude a video codec engine 1606 to encode, decode, or transcode mediato, from, or between one or more media encoding formats, including, butnot limited to Moving Picture Experts Group (MPEG) formats such asMPEG-2, Advanced Video Coding (AVC) formats such as H.264/MPEG-4 AVC,H.265/HEVC, Alliance for Open Media (AOMedia) VP8, VP9, as well as theSociety of Motion Picture & Television Engineers (SMPTE) 421M/VC-1, andJoint Photographic Experts Group (JPEG) formats such as JPEG, and MotionJPEG (MJPEG) formats.

Graphics processor 1600 may include a block image transfer (BLIT) engine1603 to perform two-dimensional (2D) rasterizer operations including,for example, bit-boundary block transfers. However, alternatively, 2Dgraphics operations may be performed using one or more components ofgraphics processing engine (GPE) 1610. In some embodiments, GPE 1610 isa compute engine for performing graphics operations, includingthree-dimensional (3D) graphics operations and media operations.

GPE 1610 may include a 3D pipeline 1612 for performing 3D operations,such as rendering three-dimensional images and scenes using processingfunctions that act upon 3D primitive shapes (e.g., rectangle, triangle,etc.). The 3D pipeline 1612 includes programmable and fixed functionelements that perform various tasks within the element and/or spawnexecution threads to a 3D/Media subsystem 1615. While 3D pipeline 1612can be used to perform media operations, an embodiment of GPE 1610 alsoincludes a media pipeline 1616 that is specifically used to performmedia operations, such as video post-processing and image enhancement.

Media pipeline 1616 may include fixed function or programmable logicunits to perform one or more specialized media operations, such as videodecode acceleration, video de-interlacing, and video encode accelerationin place of, or on behalf of video codec engine 1606. Media pipeline1616 may additionally include a thread spawning unit to spawn threadsfor execution on 3D/Media subsystem 1615. The spawned threads performcomputations for the media operations on one or more graphics executionunits included in 3D/Media subsystem 1615.

The 3D/Media subsystem 1615 may include logic for executing threadsspawned by 3D pipeline 1612 and media pipeline 1616. The pipelines maysend thread execution requests to 3D/Media subsystem 1615, whichincludes thread dispatch logic for arbitrating and dispatching thevarious requests to available thread execution resources. The executionresources include an array of graphics execution units to process the 3Dand media threads. The 3D/Media subsystem 1615 may include one or moreinternal caches for thread instructions and data. Additionally, the3D/Media subsystem 1615 may also include shared memory, includingregisters and addressable memory, to share data between threads and tostore output data.

FIG. 16B illustrates a graphics processor 1620, being a variant of thegraphics processor 1600 and may be used in place of the graphicsprocessor 1600 and vice versa. Therefore, the disclosure of any featuresin combination with the graphics processor 1600 herein also discloses acorresponding combination with the graphics processor 1620, but is notlimited to such. The graphics processor 1620 has a tiled architecture,according to embodiments described herein. The graphics processor 1620may include a graphics processing engine cluster 1622 having multipleinstances of the graphics processing engine 1610 of FIG. 16A within agraphics engine tile 1610A-1610D. Each graphics engine tile 1610A-1610Dcan be interconnected via a set of tile interconnects 1623A-1623F. Eachgraphics engine tile 1610A-1610D can also be connected to a memorymodule or memory device 1626A-1626D via memory interconnects1625A-1625D. The memory devices 1626A-1626D can use any graphics memorytechnology. For example, the memory devices 1626A-1626D may be graphicsdouble data rate (GDDR) memory. The memory devices 1626A-1626D may behigh-bandwidth memory (HBM) modules that can be on-die with theirrespective graphics engine tile 1610A-1610D. The memory devices1626A-1626D may be stacked memory devices that can be stacked on top oftheir respective graphics engine tile 1610A-1610D. Each graphics enginetile 1610A-1610D and associated memory 1626A-1626D may reside onseparate chiplets, which are bonded to a base die or base substrate, asdescribed in further detail in FIG. 24B-24D.

The graphics processor 1620 may be configured with a non-uniform memoryaccess (NUMA) system in which memory devices 1626A-1626D are coupledwith associated graphics engine tiles 1610A-1610D. A given memory devicemay be accessed by graphics engine tiles other than the tile to which itis directly connected. However, access latency to the memory devices1626A-1626D may be lowest when accessing a local tile. In oneembodiment, a cache coherent NUMA (ccNUMA) system is enabled that usesthe tile interconnects 1623A-1623F to enable communication between cachecontrollers within the graphics engine tiles 1610A-1610D to keep aconsistent memory image when more than one cache stores the same memorylocation.

The graphics processing engine cluster 1622 can connect with an on-chipor on-package fabric interconnect 1624. In one embodiment the fabricinterconnect 1624 includes a network processor, network on a chip (NoC),or another switching processor to enable the fabric interconnect 1624 toact as a packet switched fabric interconnect that switches data packetsbetween components of the graphics processor 1620. The fabricinterconnect 1624 can enable communication between graphics engine tiles1610A-1610D and components such as the video codec engine 1606 and oneor more copy engines 1604. The copy engines 1604 can be used to movedata out of, into, and between the memory devices 1626A-1626D and memorythat is external to the graphics processor 1620 (e.g., system memory).The fabric interconnect 1624 can also be used to interconnect thegraphics engine tiles 1610A-1610D. The graphics processor 1620 mayoptionally include a display controller 1602 to enable a connection withan external display device 1618. The graphics processor may also beconfigured as a graphics or compute accelerator. In the acceleratorconfiguration, the display controller 1602 and display device 1618 maybe omitted.

The graphics processor 1620 can connect to a host system via a hostinterface 1628. The host interface 1628 can enable communication betweenthe graphics processor 1620, system memory, and/or other systemcomponents. The host interface 1628 can be, for example, a PCI expressbus or another type of host system interface. For example, the hostinterface 1628 may be an NVLink or NVSwitch interface. The hostinterface 1628 and fabric interconnect 1624 can cooperate to enablemultiple instances of the graphics processor 1620 to act as singlelogical device. Cooperation between the host interface 1628 and fabricinterconnect 1624 can also enable the individual graphics engine tiles1610A-1610D to be presented to the host system as distinct logicalgraphics devices.

FIG. 16C illustrates a compute accelerator 1630, according toembodiments described herein. The compute accelerator 1630 can includearchitectural similarities with the graphics processor 1620 of FIG. 16Band is optimized for compute acceleration. A compute engine cluster 1632can include a set of compute engine tiles 1640A-1640D that includeexecution logic that is optimized for parallel or vector-basedgeneral-purpose compute operations. The compute engine tiles 1640A-1640Dmay not include fixed function graphics processing logic, although insome embodiments one or more of the compute engine tiles 1640A-1640D caninclude logic to perform media acceleration. The compute engine tiles1640A-1640D can connect to memory 1626A-1626D via memory interconnects1625A-1625D. The memory 1626A-1626D and memory interconnects 1625A-1625Dmay be similar technology as in graphics processor 1620, or can bedifferent. The graphics compute engine tiles 1640A-1640D can also beinterconnected via a set of tile interconnects 1623A-1623F and may beconnected with and/or interconnected by a fabric interconnect 1624. Inone embodiment the compute accelerator 1630 includes a large L3 cache1636 that can be configured as a device-wide cache. The computeaccelerator 1630 can also connect to a host processor and memory via ahost interface 1628 in a similar manner as the graphics processor 1620of FIG. 16B.

The compute accelerator 1630 can also include an integrated networkinterface 1642. In one embodiment the network interface 1642 includes anetwork processor and controller logic that enables the compute enginecluster 1632 to communicate over a physical layer interconnect 1644without requiring data to traverse memory of a host system. In oneembodiment, one of the compute engine tiles 1640A-1640D is replaced bynetwork processor logic and data to be transmitted or received via thephysical layer interconnect 1644 may be transmitted directly to or frommemory 1626A-1626D. Multiple instances of the compute accelerator 1630may be joined via the physical layer interconnect 1644 into a singlelogical device. Alternatively, the various compute engine tiles1640A-1640D may be presented as distinct network accessible computeaccelerator devices.

Graphics Processing Engine

FIG. 17 is a block diagram of a graphics processing engine 1710 of agraphics processor in accordance with some embodiments. The graphicsprocessing engine (GPE) 1710 may be a version of the GPE 1610 shown inFIG. 16A, and may also represent a graphics engine tile 1610A-1610D ofFIG. 16B. The elements of FIG. 17 having the same or similar names asthe elements of any other figure herein describe the same elements as inthe other figures, can operate or function in a manner similar to that,can comprise the same components, and can be linked to other entities,as those described elsewhere herein, but are not limited to such. Forexample, the 3D pipeline 1612 and media pipeline 1616 of FIG. 16A arealso illustrated in FIG. 17. The media pipeline 1616 is optional in someembodiments of the GPE 1710 and may not be explicitly included withinthe GPE 1710. For example and in at least one embodiment, a separatemedia and/or image processor is coupled to the GPE 1710.

GPE 1710 may couple with or include a command streamer 1703, whichprovides a command stream to the 3D pipeline 1612 and/or media pipelines1616. Alternatively or additionally, the command streamer 1703 may bedirectly coupled to a unified return buffer 1718. The unified returnbuffer 1718 may be communicatively coupled to a graphics core array1714. Optionally, the command streamer 1703 is coupled with memory,which can be system memory, or one or more of internal cache memory andshared cache memory. The command streamer 1703 may receive commands fromthe memory and sends the commands to 3D pipeline 1612 and/or mediapipeline 1616. The commands are directives fetched from a ring buffer,which stores commands for the 3D pipeline 1612 and media pipeline 1616.The ring buffer can additionally include batch command buffers storingbatches of multiple commands. The commands for the 3D pipeline 1612 canalso include references to data stored in memory, such as but notlimited to vertex and geometry data for the 3D pipeline 1612 and/orimage data and memory objects for the media pipeline 1616. The 3Dpipeline 1612 and media pipeline 1616 process the commands and data byperforming operations via logic within the respective pipelines or bydispatching one or more execution threads to the graphics core array1714. The graphics core array 1714 may include one or more blocks ofgraphics cores (e.g., graphics core(s) 1715A, graphics core(s) 1715B),each block including one or more graphics cores. Each graphics coreincludes a set of graphics execution resources that includesgeneral-purpose and graphics specific execution logic to performgraphics and compute operations, as well as fixed function textureprocessing and/or machine learning and artificial intelligenceacceleration logic.

In various embodiments the 3D pipeline 1612 can include fixed functionand programmable logic to process one or more shader programs, such asvertex shaders, geometry shaders, pixel shaders, fragment shaders,compute shaders, or other shader programs, by processing theinstructions and dispatching execution threads to the graphics corearray 1714. The graphics core array 1714 provides a unified block ofexecution resources for use in processing these shader programs.Multi-purpose execution logic (e.g., execution units) within thegraphics core(s) 1715A-1715B of the graphics core array 1714 includessupport for various 3D API shader languages and can execute multiplesimultaneous execution threads associated with multiple shaders.

The graphics core array 1714 may include execution logic to performmedia functions, such as video and/or image processing. The executionunits may include general-purpose logic that is programmable to performparallel general-purpose computational operations, in addition tographics processing operations. The general-purpose logic can performprocessing operations in parallel or in conjunction with general-purposelogic within the processor core(s) 1407 of FIG. 14 or core 1502A-1502Nas in FIG. 15A.

Output data generated by threads executing on the graphics core array1714 can output data to memory in a unified return buffer (URB) 1718.The URB 1718 can store data for multiple threads. The URB 1718 may beused to send data between different threads executing on the graphicscore array 1714. The URB 1718 may additionally be used forsynchronization between threads on the graphics core array 1714 andfixed function logic within the shared function logic 1720.

Optionally, the graphics core array 1714 may be scalable, such that thearray includes a variable number of graphics cores, each having avariable number of execution units based on the target power andperformance level of GPE 1710. The execution resources may bedynamically scalable, such that execution resources may be enabled ordisabled as needed.

The graphics core array 1714 couples with shared function logic 1720that includes multiple resources that are shared between the graphicscores in the graphics core array. The shared functions within the sharedfunction logic 1720 are hardware logic units that provide specializedsupplemental functionality to the graphics core array 1714. In variousembodiments, shared function logic 1720 includes but is not limited tosampler 1721, math 1722, and inter-thread communication (ITC) 1723logic. Additionally, one or more cache(s) 1725 within the sharedfunction logic 1720 may be implemented.

A shared function is implemented at least in a case where the demand fora given specialized function is insufficient for inclusion within thegraphics core array 1714. Instead a single instantiation of thatspecialized function is implemented as a stand-alone entity in theshared function logic 1720 and shared among the execution resourceswithin the graphics core array 1714. The precise set of functions thatare shared between the graphics core array 1714 and included within thegraphics core array 1714 varies across embodiments. Specific sharedfunctions within the shared function logic 1720 that are usedextensively by the graphics core array 1714 may be included withinshared function logic 1716 within the graphics core array 1714.Optionally, the shared function logic 1716 within the graphics corearray 1714 can include some or all logic within the shared functionlogic 1720. All logic elements within the shared function logic 1720 maybe duplicated within the shared function logic 1716 of the graphics corearray 1714. Alternatively, the shared function logic 1720 is excluded infavor of the shared function logic 1716 within the graphics core array1714.

Execution Units

FIG. 18A-18B illustrate thread execution logic 1800 including an arrayof processing elements employed in a graphics processor core accordingto embodiments described herein. The elements of FIG. 18A-18B having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. FIG. 18A-18B illustrates anoverview of thread execution logic 1800, which may be representative ofhardware logic illustrated with each sub-core 1521A-1521F of FIG. 15B.FIG. 18A is representative of an execution unit within a general-purposegraphics processor, while FIG. 18B is representative of an executionunit that may be used within a compute accelerator.

As illustrated in FIG. 18A, thread execution logic 1800 may include ashader processor 1802, a thread dispatcher 1804, instruction cache 1806,a scalable execution unit array including a plurality of graphicsexecution units 1808A-1808N, a sampler 1810, shared local memory 1811, adata cache 1812, and a data port 1814. Optionally, the scalableexecution unit array can dynamically scale by enabling or disabling oneor more execution units (e.g., any of graphics execution units 1808A,1808B, 1808C, 1808D, through 1808N-1 and 1808N) based on thecomputational requirements of a workload. The included components may beinterconnected via an interconnect fabric that links to each of thecomponents. Thread execution logic 1800 may include one or moreconnections to memory, such as system memory or cache memory, throughone or more of instruction cache 1806, data port 1814, sampler 1810, andgraphics execution units 1808A-1808N. Each execution unit (e.g. 1808A)may be a stand-alone programmable general-purpose computational unitthat is capable of executing multiple simultaneous hardware threadswhile processing multiple data elements in parallel for each thread. Invarious embodiments, the array of execution units 1808A-1808N isscalable to include any number individual execution units.

In some embodiments the graphics execution units 1808A-1808N may beprimarily used to execute shader programs. A shader processor 1802 canprocess the various shader programs and dispatch execution threadsassociated with the shader programs via a thread dispatcher 1804. Thethread dispatcher may include logic to arbitrate thread initiationrequests from the graphics and media pipelines and instantiate therequested threads on one or more execution units in the graphicsexecution units 1808A-1808N. For example, a geometry pipeline candispatch vertex, tessellation, or geometry shaders to the threadexecution logic for processing. Optionally, the thread dispatcher 1804can also process runtime thread spawning requests from the executingshader programs.

In some embodiments, the graphics execution units 1808A-1808N maysupport an instruction set that includes native support for manystandard 3D graphics shader instructions, such that shader programs fromgraphics libraries (e.g., Direct 3D and OpenGL) are executed with aminimal translation. The execution units support vertex and geometryprocessing (e.g., vertex programs, geometry programs, vertex shaders),pixel processing (e.g., pixel shaders, fragment shaders) andgeneral-purpose processing (e.g., compute and media shaders). Each ofthe graphics execution units 1808A-1808N is capable of multi-issuesingle instruction multiple data (SIMD) execution and multi-threadedoperation enables an efficient execution environment in the face ofhigher latency memory accesses. Each hardware thread within eachexecution unit has a dedicated high-bandwidth register file andassociated independent thread-state. Execution is multi-issue per clockto pipelines capable of integer, single and double precision floatingpoint operations, SIMD branch capability, logical operations,transcendental operations, and other miscellaneous operations. Whilewaiting for data from memory or one of the shared functions, dependencylogic within the execution units 1808A-1808N causes a waiting thread tosleep until the requested data has been returned. While the waitingthread is sleeping, hardware resources may be devoted to processingother threads. For example, during a delay associated with a vertexshader operation, an execution unit can perform operations for a pixelshader, fragment shader, or another type of shader program, including adifferent vertex shader, such as vertex shader 2107 illustrated in FIG.21. Various embodiments can apply to use execution by use of SingleInstruction Multiple Thread (SIMT) as an alternate to use of SIMD or inaddition to use of SIMD. Reference to a SIMD core or operation can applyalso to SIMT or apply to SIMD in combination with SIMT.

Each execution unit in graphics execution units 1808A-1808N operates onarrays of data elements. The number of data elements is the “executionsize,” or the number of channels for the instruction. An executionchannel is a logical unit of execution for data element access, masking,and flow control within instructions. The number of channels may beindependent of the number of physical Arithmetic Logic Units (ALUs),Floating-Point Units (FPUs), or other logic units (e.g., tensor cores,ray tracing cores, etc.) for a particular graphics processor.Additionally, the graphics execution units 1808A-1808N may supportinteger and floating-point data types.

The execution unit instruction set includes SIMD instructions. Thevarious data elements can be stored as a packed data type in a registerand the execution unit will process the various elements based on thedata size of the elements. For example, when operating on a 256-bit widevector, the 256 bits of the vector are stored in a register and theexecution unit operates on the vector as four separate 184-bit packeddata elements (Quad-Word (QW) size data elements), eight separate 32-bitpacked data elements (Double Word (DW) size data elements), sixteenseparate 16-bit packed data elements (Word (W) size data elements), orthirty-two separate 8-bit data elements (byte (B) size data elements).However, different vector widths and register sizes are possible.

Optionally, one or more execution units can be combined into a fusedgraphics execution unit 1809A-1809N having thread control logic(1807A-1807N) that is common to the fused EUs. Multiple EUs can be fusedinto an EU group. Each EU in the fused EU group can be configured toexecute a separate SIMD hardware thread. The number of EUs in a fused EUgroup can vary according to embodiments. Additionally, various SIMDwidths can be performed per-EU, including but not limited to SIMD8,SIMD16, and SIMD32. Each fused graphics execution unit 1809A-1809Nincludes at least two execution units. For example, fused execution unit1809A includes a first EU 1808A, second EU 1808B, and thread controllogic 1807A that is common to the first EU 1808A and the second EU1808B. The thread control logic 1807A controls threads executed on thefused graphics execution unit 1809A, allowing each EU within the fusedexecution units 1809A-1809N to execute using a common instructionpointer register.

One or more internal instruction caches (e.g., 1806) are included in thethread execution logic 1800 to cache thread instructions for theexecution units. One or more data caches (e.g., 1812) may be included inthe thread execution logic 1800 to cache thread data during threadexecution. Threads executing on the execution logic 1800 can also storeexplicitly managed data in the shared local memory 1811. A sampler 1810may be included to provide texture sampling for 3D operations and mediasampling for media operations. Sampler 1810 may include specializedtexture or media sampling functionality to process texture or media dataduring the sampling process before providing the sampled data to anexecution unit.

During execution, the graphics and media pipelines send threadinitiation requests to thread execution logic 1800 via thread spawningand dispatch logic. Once a group of geometric objects has been processedand rasterized into pixel data, pixel processor logic (e.g., pixelshader logic, fragment shader logic, etc.) within the shader processor1802 is invoked to further compute output information and cause resultsto be written to output surfaces (e.g., color buffers, depth buffers,stencil buffers, etc.). A pixel shader or fragment shader may calculatethe values of the various vertex attributes that are to be interpolatedacross the rasterized object. The pixel processor logic within theshader processor 1802 may then execute an application programminginterface (API)-supplied pixel or fragment shader program. To executethe shader program, the shader processor 1802 dispatches threads to anexecution unit (e.g., 1808A) via thread dispatcher 1804. Shaderprocessor 1802 may use texture sampling logic in the sampler 1810 toaccess texture data in texture maps stored in memory. Arithmeticoperations on the texture data and the input geometry data compute pixelcolor data for each geometric fragment, or discards one or more pixelsfrom further processing.

In addition, the data port 1814 may provide a memory access mechanismfor the thread execution logic 1800 to output processed data to memoryfor further processing on a graphics processor output pipeline. The dataport 1814 may include or couple to one or more cache memories (e.g.,data cache 1812) to cache data for memory access via the data port 1814.

Optionally, the execution logic 1800 can also include a ray tracer 1805that can provide ray tracing acceleration functionality. The ray tracer1805 can support a ray tracing instruction set that includesinstructions/functions for ray generation. The ray tracing instructionset can be similar to or different from the ray-tracing instruction setsupported by the ray tracing cores 372 in FIG. 3C.

FIG. 18B illustrates exemplary internal details of an execution unit1808. A graphics execution unit 1808 can include an instruction fetchunit 1837, a general register file array (GRF) 1824, an architecturalregister file array (ARF) 1826, a thread arbiter 1822, a send unit 1830,a branch unit 1832, a set of SIMD floating point units (FPUs) 1834, andoptionally a set of dedicated integer SIMD ALUs 1835. The GRF 1824 andARF 1826 includes the set of general register files and architectureregister files associated with each simultaneous hardware thread thatmay be active in the graphics execution unit 1808. Per threadarchitectural state may be maintained in the ARF 1826, while data usedduring thread execution is stored in the GRF 1824. The execution stateof each thread, including the instruction pointers for each thread, canbe held in thread-specific registers in the ARF 1826.

The graphics execution unit 1808 may have an architecture that is acombination of Simultaneous Multi-Threading (SMT) and fine-grainedInterleaved Multi-Threading (IMT). The architecture may have a modularconfiguration that can be fine-tuned at design time based on a targetnumber of simultaneous threads and number of registers per executionunit, where execution unit resources are divided across logic used toexecute multiple simultaneous threads. The number of logical threadsthat may be executed by the graphics execution unit 1808 is not limitedto the number of hardware threads, and multiple logical threads can beassigned to each hardware thread.

Optionally, the graphics execution unit 1808 can co-issue multipleinstructions, which may each be different instructions. The threadarbiter 1822 of the graphics execution unit thread 1808 can dispatch theinstructions to one of the send unit 1830, branch unit 1832, or SIMDFPU(s) 1834 for execution. Each execution thread can access 128general-purpose registers within the GRF 1824, where each register canstore 32 bytes, accessible as a SIMD 8-element vector of 32-bit dataelements. Each execution unit thread may have access to 4 Kbytes withinthe GRF 1824, although embodiments are not so limited, and greater orfewer register resources may be provided in other embodiments. Thegraphics execution unit 1808 may be partitioned into seven hardwarethreads that can independently perform computational operations,although the number of threads per execution unit can also varyaccording to embodiments, for example, up to 16 hardware threads may besupported. In an exemplary embodiment, in which seven threads may access4 Kbytes, the GRF 1824 can store a total of 28 Kbytes. In anotherexemplary embodiment, where 16 threads may access 4 Kbytes, the GRF 1824can store a total of 64Kbytes. The number of threads per execution unitare, however, not limited to those examples and may be more or less thanthe given numbers. Flexible addressing modes can permit registers to beaddressed together to build effectively wider registers or to representstrided rectangular block data structures.

Additionally or alternatively, memory operations, sampler operations,and other longer-latency system communications may be dispatched via“send” instructions that are executed by the message passing send unit1830. Branch instructions may be dispatched to a dedicated branch unit1832 to facilitate SIMD divergence and eventual convergence.

The graphics execution unit 1808 may include one or more SIMD floatingpoint units (FPU(s)) 1834 to perform floating-point operations. TheFPU(s) 1834 may also support integer computation. In some instances, theFPU(s) 1834 can SIMD execute up to M number of 32-bit floating-point (orinteger) operations, or SIMD execute up to 2M 16-bit integer or 16-bitfloating-point operations. Optionally, at least one of the FPU(s)provides extended math capability to support high-throughputtranscendental math functions and double precision 184-bitfloating-point. A set of 8-bit integer SIMD ALUs 1835 may also bepresent, and may be specifically optimized to perform operationsassociated with machine learning computations.

Optionally, arrays of multiple instances of the graphics execution unit1808 can be instantiated in a graphics sub-core grouping (e.g., asub-slice). For scalability, product architects can choose the exactnumber of execution units per sub-core grouping. The execution unit 1808may execute instructions across a plurality of execution channels. Inaddition, each thread executed on the graphics execution unit 1808 maybe executed on a different channel.

FIG. 19 illustrates a further exemplary execution unit 1900. Theelements of FIG. 19 having the same or similar names as the elements ofany other figure herein describe the same elements as in the otherfigures, can operate or function in a manner similar to that, cancomprise the same components, and can be linked to other entities, asthose described elsewhere herein, but are not limited to such. Theexecution unit 1900 may be a compute-optimized execution unit for usein, for example, a compute engine tile 1640A-1640D as in FIG. 16C, butis not limited as such. The execution unit 1900 may also be used in agraphics engine tile 1610A-1610D as in FIG. 16B. The execution unit 1900may include a thread control unit 1901, a thread state unit 1902, aninstruction fetch/prefetch unit 1903, and an instruction decode unit1904. The execution unit 1900 may additionally include a register file1906 that stores registers that can be assigned to hardware threadswithin the execution unit. The execution unit 1900 may additionallyinclude a send unit 1907 and a branch unit 1908. The send unit 1907 andbranch unit 1908 may operate similarly as the send unit 1830 and abranch unit 1832 of the graphics execution unit 1808 of FIG. 18B.

The execution unit 1900 can also include a compute unit 1910 thatincludes multiple different types of functional units. The compute unit1910 may also include an ALU 1911, a systolic array 1912, and a mathunit 1913. The ALU 1911 includes an array of arithmetic logic units. TheALU 1911 can be configured to perform 64-bit, 32-bit, and 16-bit integerand floating-point operations across multiple processing lanes and datachannels and for multiple hardware and/or software threads. The ALU 1911can perform integer and floating-point operations simultaneously (e.g.,within the same clock cycle).

The systolic array 1912 includes a W wide and D deep network of dataprocessing units that can be used to perform vector or otherdata-parallel operations in a systolic manner. The systolic array 1912can be configured to perform various matrix operations, including as dotproduct, outer product, and general matrix-matrix multiplication (GEMM)operations. The systolic array 1912 may support 16-bit floating pointoperations, as well as 8-bit, 4-bit, 2-bit, and binary integeroperations. The systolic array 1912 may be configured to acceleratemachine learning operations. The systolic array 1912 can be configuredwith support for bfloat16, (brain floating point) 16-bit floating pointformat or a tensor float 32-bit floating point format (TF32) that havedifferent numbers of mantissa and exponent bits relative to Institute ofElectrical and Electronics Engineers (IEEE) 754 formats. FP64 formatscan also be supported.

In one embodiment, the systolic array 1912 includes hardware toaccelerate sparse matrix operations. Multiplication operations forsparse regions of input data can be bypassed without sacrificingthroughput. Block sparsity within input matrices can be detected andoperations having known output values can be bypassed. In oneembodiment, the systolic array 1912 includes hardware to enableoperations on sparse data having a compressed representation. Acompressed representation of a sparse matrix stores non-zero values andmetadata that defines the position of the non-zero values within thematrix. Exemplary compressed representations include but are not limitedto compressed tensor representations such as compressed sparse row(CSR), compressed sparse column (CSC), compressed sparse fiber (CSF)representations. Support for compressed representations enableoperations to be performed on input in a compressed tensor formatwithout requiring the compressed representation to be decompressed ordecoded. In such embodiment, operations can be performed only onnon-zero input values and the resulting non-zero output values can bemapped into an output matrix. In some embodiments, hardware support isalso provided for machine-specific lossless data compression formatsthat are used when transmitting data within hardware or across systembusses. Such data may be retained in a compressed format for sparseinput data and the systolic array 1912 can used the compression metadatafor the compressed data to enable operations to be performed on onlynon-zero values, or to enable blocks of zero data input to be bypassedfor multiply operations.

The math unit 1913 can be configured to perform a specific subset ofmathematical operations in an efficient and lower-power manner than thenALU unit 1911. The math unit 1913 can include math logic found in sharedfunction logic of a graphics processing engine provided by otherembodiments described, e.g., the math logic 1722 of the shared functionlogic 1720 of FIG. 17. The math unit 1913 can be configured to perform32-bit and 64-bit floating point operations.

The thread control unit 1901 includes logic to control the execution ofthreads within the execution unit. The thread control unit 1901 caninclude thread arbitration logic to start, stop, and preempt executionof threads within the execution unit 1900. The thread state unit 1902can be used to store thread state for threads assigned to execute on theexecution unit 1900. Storing the thread state within the execution unit1900 enables the rapid pre-emption of threads when those threads becomeblocked or idle. The instruction fetch/prefetch unit 1903 can fetchinstructions from an instruction cache of higher-level execution logic(e.g., instruction cache 1806 as in FIG. 18A). The instructionfetch/prefetch unit 1903 can also issue prefetch requests forinstructions to be loaded into the instruction cache based on ananalysis of currently executing threads. The instruction decode unit1904 can be used to decode instructions to be executed by the computeunits. The instruction decode unit 1904 can be used as a secondarydecoder to decode complex instructions into constituentmicro-operations.

The execution unit 1900 additionally includes a register file 1906 thatcan be used by hardware threads executing on the execution unit 1900.Registers in the register file 1906 can be divided across the logic usedto execute multiple simultaneous threads within the compute unit 1910 ofthe execution unit 1900. The number of logical threads that may beexecuted by the graphics execution unit 1900 is not limited to thenumber of hardware threads, and multiple logical threads can be assignedto each hardware thread. The size of the register file 1906 can varyacross embodiments based on the number of supported hardware threads.Register renaming may be used to dynamically allocate registers tohardware threads.

FIG. 20 is a block diagram illustrating graphics processor instructionformats 2000. The graphics processor execution units support aninstruction set having instructions in multiple formats. The solid linedboxes illustrate the components that are generally included in anexecution unit instruction, while the dashed lines include componentsthat are optional or that are only included in a sub-set of theinstructions. In some embodiments the graphics processor instructionformats 2000 described and illustrated are macro-instructions, in thatthey are instructions supplied to the execution unit, as opposed tomicro-operations resulting from instruction decode once the instructionis processed. Thus, a single instructions may cause hardware to performmultiple micro-operations

The graphics processor execution units as described herein may nativelysupport instructions in a 128-bit instruction format 2010. A 64-bitcompacted instruction format 2030 is available for some instructionsbased on the selected instruction, instruction options, and number ofoperands. The native 128-bit instruction format 2010 provides access toall instruction options, while some options and operations arerestricted in the 64-bit format 2030. The native instructions availablein the 64-bit format 2030 vary by embodiment. The instruction iscompacted in part using a set of index values in an index field 2013.The execution unit hardware references a set of compaction tables basedon the index values and uses the compaction table outputs to reconstructa native instruction in the 128-bit instruction format 2010. Other sizesand formats of instruction can be used.

For each format, instruction opcode 2012 defines the operation that theexecution unit is to perform. The execution units execute eachinstruction in parallel across the multiple data elements of eachoperand. For example, in response to an add instruction the executionunit performs a simultaneous add operation across each color channelrepresenting a texture element or picture element. By default, theexecution unit performs each instruction across all data channels of theoperands. Instruction control field 2014 may enable control over certainexecution options, such as channels selection (e.g., predication) anddata channel order (e.g., swizzle). For instructions in the 128-bitinstruction format 2010 an exec-size field 2016 limits the number ofdata channels that will be executed in parallel. An exec-size field 2016may not be available for use in the 64-bit compact instruction format2030.

Some execution unit instructions have up to three operands including twosource operands, src0 2020, src1 2022, and one destination 2018. Theexecution units may support dual destination instructions, where one ofthe destinations is implied. Data manipulation instructions can have athird source operand (e.g., SRC2 2024), where the instruction opcode2012 determines the number of source operands. An instruction's lastsource operand can be an immediate (e.g., hard-coded) value passed withthe instruction.

The 128-bit instruction format 2010 may include an access/address modefield 2026 specifying, for example, whether direct register addressingmode or indirect register addressing mode is used. When direct registeraddressing mode is used, the register address of one or more operands isdirectly provided by bits in the instruction.

The 128-bit instruction format 2010 may also include an access/addressmode field 2026, which specifies an address mode and/or an access modefor the instruction. The access mode may be used to define a data accessalignment for the instruction. Access modes including a 16-byte alignedaccess mode and a 1-byte aligned access mode may be supported, where thebyte alignment of the access mode determines the access alignment of theinstruction operands. For example, when in a first mode, the instructionmay use byte-aligned addressing for source and destination operands andwhen in a second mode, the instruction may use 16-byte-alignedaddressing for all source and destination operands.

The address mode portion of the access/address mode field 2026 maydetermine whether the instruction is to use direct or indirectaddressing. When direct register addressing mode is used bits in theinstruction directly provide the register address of one or moreoperands. When indirect register addressing mode is used, the registeraddress of one or more operands may be computed based on an addressregister value and an address immediate field in the instruction.

Instructions may be grouped based on opcode 2012 bit-fields to simplifyOpcode decode 2040. For an 8-bit opcode, bits 4, 5, and 6 allow theexecution unit to determine the type of opcode. The precise opcodegrouping shown is merely an example. A move and logic opcode group 2042may include data movement and logic instructions (e.g., move (mov),compare (cmp)). Move and logic group 2042 may share the five leastsignificant bits (LSB), where move (mov) instructions are in the form of0000xxxxb and logic instructions are in the form of 0001xxxxb. A flowcontrol instruction group 2044 (e.g., call, jump (jmp)) includesinstructions in the form of 0010xxxxb (e.g., 0x20). A miscellaneousinstruction group 2046 includes a mix of instructions, includingsynchronization instructions (e.g., wait, send) in the form of 0011xxxxb(e.g., 0x30). A parallel math instruction group 2048 includescomponent-wise arithmetic instructions (e.g., add, multiply (mul)) inthe form of 0100xxxxb (e.g., 0x40). The parallel math instruction group2048 performs the arithmetic operations in parallel across datachannels. The vector math group 2050 includes arithmetic instructions(e.g., dp4) in the form of 0101xxxxb (e.g., 0x50). The vector math groupperforms arithmetic such as dot product calculations on vector operands.The illustrated opcode decode 2040, in one embodiment, can be used todetermine which portion of an execution unit will be used to execute adecoded instruction. For example, some instructions may be designated assystolic instructions that will be performed by a systolic array. Otherinstructions, such as ray-tracing instructions (not shown) can be routedto a ray-tracing core or ray-tracing logic within a slice or partitionof execution logic.

Graphics Pipeline

FIG. 21 is a block diagram of graphics processor 2100, according toanother embodiment. The elements of FIG. 21 having the same or similarnames as the elements of any other figure herein describe the sameelements as in the other figures, can operate or function in a mannersimilar to that, can comprise the same components, and can be linked toother entities, as those described elsewhere herein, but are not limitedto such.

The graphics processor 2100 may include different types of graphicsprocessing pipelines, such as a geometry pipeline 2120, a media pipeline2130, a display engine 2140, thread execution logic 2150, and a renderoutput pipeline 2170. Graphics processor 2100 may be a graphicsprocessor within a multi-core processing system that includes one ormore general-purpose processing cores. The graphics processor may becontrolled by register writes to one or more control registers (notshown) or via commands issued to graphics processor 2100 via a ringinterconnect 2102. Ring interconnect 2102 may couple graphics processor2100 to other processing components, such as other graphics processorsor general-purpose processors. Commands from ring interconnect 2102 areinterpreted by a command streamer 2103, which supplies instructions toindividual components of the geometry pipeline 2120 or the mediapipeline 2130.

Command streamer 2103 may direct the operation of a vertex fetcher 2105that reads vertex data from memory and executes vertex-processingcommands provided by command streamer 2103. The vertex fetcher 2105 mayprovide vertex data to a vertex shader 2107, which performs coordinatespace transformation and lighting operations to each vertex. Vertexfetcher 2105 and vertex shader 2107 may execute vertex-processinginstructions by dispatching execution threads to execution units2152A-2152B via a thread dispatcher 2131.

The execution units 2152A-2152B may be an array of vector processorshaving an instruction set for performing graphics and media operations.The execution units 2152A-2152B may have an attached L1 cache 2151 thatis specific for each array or shared between the arrays. The cache canbe configured as a data cache, an instruction cache, or a single cachethat is partitioned to contain data and instructions in differentpartitions.

A geometry pipeline 2120 may include tessellation components to performhardware-accelerated tessellation of 3D objects. A programmable hullshader 2111 may configure the tessellation operations. A programmabledomain shader 2117 may provide back-end evaluation of tessellationoutput. A tessellator 2113 may operate at the direction of hull shader2111 and contain special purpose logic to generate a set of detailedgeometric objects based on a coarse geometric model that is provided asinput to geometry pipeline 2120. In addition, if tessellation is notused, tessellation components (e.g., hull shader 2111, tessellator 2113,and domain shader 2117) can be bypassed. The tessellation components canoperate based on data received from the vertex shader 2107.

Complete geometric objects may be processed by a geometry shader 2119via one or more threads dispatched to execution units 2152A-2152B, orcan proceed directly to the clipper 2129. The geometry shader mayoperate on entire geometric objects, rather than vertices or patches ofvertices as in previous stages of the graphics pipeline. If thetessellation is disabled the geometry shader 2119 receives input fromthe vertex shader 2107. The geometry shader 2119 may be programmable bya geometry shader program to perform geometry tessellation if thetessellation units are disabled.

Before rasterization, a clipper 2129 processes vertex data. The clipper2129 may be a fixed function clipper or a programmable clipper havingclipping and geometry shader functions. A rasterizer and depth testcomponent 2173 in the render output pipeline 2170 may dispatch pixelshaders to convert the geometric objects into per pixel representations.The pixel shader logic may be included in thread execution logic 2150.Optionally, an application can bypass the rasterizer and depth testcomponent 2173 and access un-rasterized vertex data via a stream outunit 2123.

The graphics processor 2100 has an interconnect bus, interconnectfabric, or some other interconnect mechanism that allows data andmessage passing amongst the major components of the processor. In someembodiments, execution units 2152A-2152B and associated logic units(e.g., L1 cache 2151, sampler 2154, texture cache 2158, etc.)interconnect via a data port 2156 to perform memory access andcommunicate with render output pipeline components of the processor. Asampler 2154, caches 2151, 2158 and execution units 2152A-2152B each mayhave separate memory access paths. Optionally, the texture cache 2158can also be configured as a sampler cache.

The render output pipeline 2170 may contain a rasterizer and depth testcomponent 2173 that converts vertex-based objects into an associatedpixel-based representation. The rasterizer logic may include awindower/masker unit to perform fixed function triangle and linerasterization. An associated render cache 2178 and depth cache 2179 arealso available in some embodiments. A pixel operations component 2177performs pixel-based operations on the data, though in some instances,pixel operations associated with 2D operations (e.g. bit block imagetransfers with blending) are performed by the 2D engine 2141, orsubstituted at display time by the display controller 2143 using overlaydisplay planes. A shared L3 cache 2175 may be available to all graphicscomponents, allowing the sharing of data without the use of main systemmemory.

The media pipeline 2130 may include a media engine 2137 and a videofront-end 2134. Video front-end 2134 may receive pipeline commands fromthe command streamer 2103. The media pipeline 2130 may include aseparate command streamer. Video front-end 2134 may process mediacommands before sending the command to the media engine 2137. Mediaengine 2137 may include thread spawning functionality to spawn threadsfor dispatch to thread execution logic 2150 via thread dispatcher 2131.

The graphics processor 2100 may include a display engine 2140. Thisdisplay engine 2140 may be external to processor 2100 and may couplewith the graphics processor via the ring interconnect 2102, or someother interconnect bus or fabric. Display engine 2140 may include a 2Dengine 2141 and a display controller 2143. Display engine 2140 maycontain special purpose logic capable of operating independently of the3D pipeline. Display controller 2143 may couple with a display device(not shown), which may be a system integrated display device, as in alaptop computer, or an external display device attached via a displaydevice connector.

The geometry pipeline 2120 and media pipeline 2130 maybe configurable toperform operations based on multiple graphics and media programminginterfaces and are not specific to any one application programminginterface (API). A driver software for the graphics processor maytranslate API calls that are specific to a particular graphics or medialibrary into commands that can be processed by the graphics processor.Support may be provided for the Open Graphics Library (OpenGL), OpenComputing Language (OpenCL), and/or Vulkan graphics and compute API, allfrom the Khronos Group. Support may also be provided for the Direct3Dlibrary from the Microsoft Corporation. A combination of these librariesmay be supported. Support may also be provided for the Open SourceComputer Vision Library (OpenCV). A future API with a compatible 3Dpipeline would also be supported if a mapping can be made from thepipeline of the future API to the pipeline of the graphics processor.

Graphics Pipeline Programming

FIG. 22A is a block diagram illustrating a graphics processor commandformat 2200 used for programming graphics processing pipelines, such as,for example, the pipelines described herein in conjunction with FIG.16A, 17, 21. FIG. 22B is a block diagram illustrating a graphicsprocessor command sequence 2210 according to an embodiment. The solidlined boxes in FIG. 22A illustrate the components that are generallyincluded in a graphics command while the dashed lines include componentsthat are optional or that are only included in a sub-set of the graphicscommands. The exemplary graphics processor command format 2200 of FIG.22A includes data fields to identify a client 2202, a command operationcode (opcode) 2204, and data 2206 for the command. A sub-opcode 2205 anda command size 2208 are also included in some commands.

Client 2202 may specify the client unit of the graphics device thatprocesses the command data. A graphics processor command parser mayexamine the client field of each command to condition the furtherprocessing of the command and route the command data to the appropriateclient unit. The graphics processor client units may include a memoryinterface unit, a render unit, a 2D unit, a 3D unit, and a media unit.Each client unit may have a corresponding processing pipeline thatprocesses the commands. Once the command is received by the client unit,the client unit reads the opcode 2204 and, if present, sub-opcode 2205to determine the operation to perform. The client unit performs thecommand using information in data field 2206. For some commands anexplicit command size 2208 is expected to specify the size of thecommand. The command parser may automatically determine the size of atleast some of the commands based on the command opcode. Commands may bealigned via multiples of a double word. Other command formats can alsobe used.

The flow diagram in FIG. 22B illustrates an exemplary graphics processorcommand sequence 2210. Software or firmware of a data processing systemthat features an exemplary graphics processor may use a version of thecommand sequence shown to set up, execute, and terminate a set ofgraphics operations. A sample command sequence is shown and describedfor purposes of example only and is not limited to these specificcommands or to this command sequence. Moreover, the commands may beissued as batch of commands in a command sequence, such that thegraphics processor will process the sequence of commands in at leastpartially concurrence.

The graphics processor command sequence 2210 may begin with a pipelineflush command 2212 to cause any active graphics pipeline to complete thecurrently pending commands for the pipeline. Optionally, the 3D pipeline2222 and the media pipeline 2224 may not operate concurrently. Thepipeline flush is performed to cause the active graphics pipeline tocomplete any pending commands. In response to a pipeline flush, thecommand parser for the graphics processor will pause command processinguntil the active drawing engines complete pending operations and therelevant read caches are invalidated. Optionally, any data in the rendercache that is marked ‘dirty’ can be flushed to memory. Pipeline flushcommand 2212 can be used for pipeline synchronization or before placingthe graphics processor into a low power state.

A pipeline select command 2213 may be used when a command sequencerequires the graphics processor to explicitly switch between pipelines.A pipeline select command 2213 may be required only once within anexecution context before issuing pipeline commands unless the context isto issue commands for both pipelines. A pipeline flush command 2212 maybe required immediately before a pipeline switch via the pipeline selectcommand 2213.

A pipeline control command 2214 may configure a graphics pipeline foroperation and may be used to program the 3D pipeline 2222 and the mediapipeline 2224. The pipeline control command 2214 may configure thepipeline state for the active pipeline. The pipeline control command2214 may be used for pipeline synchronization and to clear data from oneor more cache memories within the active pipeline before processing abatch of commands.

Commands related to the return buffer state 2216 may be used toconfigure a set of return buffers for the respective pipelines to writedata. Some pipeline operations require the allocation, selection, orconfiguration of one or more return buffers into which the operationswrite intermediate data during processing. The graphics processor mayalso use one or more return buffers to store output data and to performcross thread communication. The return buffer state 2216 may includeselecting the size and number of return buffers to use for a set ofpipeline operations.

The remaining commands in the command sequence differ based on theactive pipeline for operations. Based on a pipeline determination 2220,the command sequence is tailored to the 3D pipeline 2222 beginning withthe 3D pipeline state 2230 or the media pipeline 2224 beginning at themedia pipeline state 2240.

The commands to configure the 3D pipeline state 2230 include 3D statesetting commands for vertex buffer state, vertex element state, constantcolor state, depth buffer state, and other state variables that are tobe configured before 3D primitive commands are processed. The values ofthese commands are determined at least in part based on the particular3D API in use. The 3D pipeline state 2230 commands may also be able toselectively disable or bypass certain pipeline elements if thoseelements will not be used.

A 3D primitive 2232 command may be used to submit 3D primitives to beprocessed by the 3D pipeline. Commands and associated parameters thatare passed to the graphics processor via the 3D primitive 2232 commandare forwarded to the vertex fetch function in the graphics pipeline. Thevertex fetch function uses the 3D primitive 2232 command data togenerate vertex data structures. The vertex data structures are storedin one or more return buffers. The 3D primitive 2232 command may be usedto perform vertex operations on 3D primitives via vertex shaders. Toprocess vertex shaders, 3D pipeline 2222 dispatches shader executionthreads to graphics processor execution units.

The 3D pipeline 2222 may be triggered via an execute 2234 command orevent. A register may write trigger command executions. An execution maybe triggered via a ‘go’ or ‘kick’ command in the command sequence.Command execution may be triggered using a pipeline synchronizationcommand to flush the command sequence through the graphics pipeline. The3D pipeline will perform geometry processing for the 3D primitives. Onceoperations are complete, the resulting geometric objects are rasterizedand the pixel engine colors the resulting pixels. Additional commands tocontrol pixel shading and pixel back end operations may also be includedfor those operations.

The graphics processor command sequence 2210 may follow the mediapipeline 2224 path when performing media operations. In general, thespecific use and manner of programming for the media pipeline 2224depends on the media or compute operations to be performed. Specificmedia decode operations may be offloaded to the media pipeline duringmedia decode. The media pipeline can also be bypassed and media decodecan be performed in whole or in part using resources provided by one ormore general-purpose processing cores. The media pipeline may alsoinclude elements for general-purpose graphics processor unit (GPGPU)operations, where the graphics processor is used to perform SIMD vectoroperations using computational shader programs that are not explicitlyrelated to the rendering of graphics primitives.

Media pipeline 2224 may be configured in a similar manner as the 3Dpipeline 2222. A set of commands to configure the media pipeline state2240 are dispatched or placed into a command queue before the mediaobject commands 2242. Commands for the media pipeline state 2240 mayinclude data to configure the media pipeline elements that will be usedto process the media objects. This includes data to configure the videodecode and video encode logic within the media pipeline, such as encodeor decode format. Commands for the media pipeline state 2240 may alsosupport the use of one or more pointers to “indirect” state elementsthat contain a batch of state settings.

Media object commands 2242 may supply pointers to media objects forprocessing by the media pipeline. The media objects include memorybuffers containing video data to be processed. Optionally, all mediapipeline states must be valid before issuing a media object command2242. Once the pipeline state is configured and media object commands2242 are queued, the media pipeline 2224 is triggered via an executecommand 2244 or an equivalent execute event (e.g., register write).Output from media pipeline 2224 may then be post processed by operationsprovided by the 3D pipeline 2222 or the media pipeline 2224. GPGPUoperations may be configured and executed in a similar manner as mediaoperations.

Graphics Software Architecture

FIG. 23 illustrates an exemplary graphics software architecture for adata processing system 2300. Such a software architecture may include a3D graphics application 2310, an operating system 2320, and at least oneprocessor 2330. Processor 2330 may include a graphics processor 2332 andone or more general-purpose processor core(s) 2334. The processor 2330may be a variant of the processor 1402 or any other of the processorsdescribed herein. The processor 2330 may be used in place of theprocessor 1402 or any other of the processors described herein.Therefore, the disclosure of any features in combination with theprocessor 1402 or any other of the processors described herein alsodiscloses a corresponding combination with the graphics processor 2330,but is not limited to such. Moreover, the elements of FIG. 23 having thesame or similar names as the elements of any other figure hereindescribe the same elements as in the other figures, can operate orfunction in a manner similar to that, can comprise the same components,and can be linked to other entities, as those described elsewhereherein, but are not limited to such. The graphics application 2310 andoperating system 2320 are each executed in the system memory 2350 of thedata processing system.

3D graphics application 2310 may contain one or more shader programsincluding shader instructions 2312. The shader language instructions maybe in a high-level shader language, such as the High-Level ShaderLanguage (HLSL) of Direct3D, the OpenGL Shader Language (GLSL), and soforth. The application may also include executable instructions 2314 ina machine language suitable for execution by the general-purposeprocessor core 2334. The application may also include graphics objects2316 defined by vertex data.

The operating system 2320 may be a Microsoft® Windows® operating systemfrom the Microsoft Corporation, a proprietary UNIX-like operatingsystem, or an open source UNIX-like operating system using a variant ofthe Linux kernel. The operating system 2320 can support a graphics API2322 such as the Direct3D API, the OpenGL API, or the Vulkan API. Whenthe Direct3D API is in use, the operating system 2320 uses a front-endshader compiler 2324 to compile any shader instructions 2312 in HLSLinto a lower-level shader language. The compilation may be ajust-in-time (JIT) compilation or the application can perform shaderpre-compilation. High-level shaders may be compiled into low-levelshaders during the compilation of the 3D graphics application 2310. Theshader instructions 2312 may be provided in an intermediate form, suchas a version of the Standard Portable Intermediate Representation (SPIR)used by the Vulkan API.

User mode graphics driver 2326 may contain a back-end shader compiler2327 to convert the shader instructions 2312 into a hardware specificrepresentation. When the OpenGL API is in use, shader instructions 2312in the GLSL high-level language are passed to a user mode graphicsdriver 2326 for compilation. The user mode graphics driver 2326 may useoperating system kernel mode functions 2328 to communicate with a kernelmode graphics driver 2329. The kernel mode graphics driver 2329 maycommunicate with graphics processor 2332 to dispatch commands andinstructions.

IP Core Implementations

One or more aspects may be implemented by representative code stored ona machine-readable medium which represents and/or defines logic withinan integrated circuit such as a processor. For example, themachine-readable medium may include instructions which represent variouslogic within the processor. When read by a machine, the instructions maycause the machine to fabricate the logic to perform the techniquesdescribed herein. Such representations, known as “IP cores,” arereusable units of logic for an integrated circuit that may be stored ona tangible, machine-readable medium as a hardware model that describesthe structure of the integrated circuit. The hardware model may besupplied to various customers or manufacturing facilities, which loadthe hardware model on fabrication machines that manufacture theintegrated circuit. The integrated circuit may be fabricated such thatthe circuit performs operations described in association with any of theembodiments described herein.

FIG. 24A is a block diagram illustrating an IP core development system2400 that may be used to manufacture an integrated circuit to performoperations according to an embodiment. The IP core development system2400 may be used to generate modular, re-usable designs that can beincorporated into a larger design or used to construct an entireintegrated circuit (e.g., an SOC integrated circuit). A design facility2430 can generate a software simulation 2410 of an IP core design in ahigh-level programming language (e.g., C/C++). The software simulation2410 can be used to design, test, and verify the behavior of the IP coreusing a simulation model 2412. The simulation model 2412 may includefunctional, behavioral, and/or timing simulations. A register transferlevel (RTL) design 2415 can then be created or synthesized from thesimulation model 2412. The RTL design 2415 is an abstraction of thebehavior of the integrated circuit that models the flow of digitalsignals between hardware registers, including the associated logicperformed using the modeled digital signals. In addition to an RTLdesign 2415, lower-level designs at the logic level or transistor levelmay also be created, designed, or synthesized. Thus, the particulardetails of the initial design and simulation may vary.

The RTL design 2415 or equivalent may be further synthesized by thedesign facility into a hardware model 2420, which may be in a hardwaredescription language (HDL), or some other representation of physicaldesign data. The HDL may be further simulated or tested to verify the IPcore design. The IP core design can be stored for delivery to a 3rdparty fabrication facility 2465 using non-volatile memory 2440 (e.g.,hard disk, flash memory, or any non-volatile storage medium).Alternatively, the IP core design may be transmitted (e.g., via theInternet) over a wired connection 2450 or wireless connection 2460. Thefabrication facility 2465 may then fabricate an integrated circuit thatis based at least in part on the IP core design. The fabricatedintegrated circuit can be configured to perform operations in accordancewith at least one embodiment described herein.

FIG. 24B illustrates a cross-section side view of an integrated circuitpackage assembly 2470. The integrated circuit package assembly 2470illustrates an implementation of one or more processor or acceleratordevices as described herein. The package assembly 2470 includes multipleunits of hardware logic 2472, 2474 connected to a substrate 2480. Thelogic 2472, 2474 may be implemented at least partly in configurablelogic or fixed-functionality logic hardware, and can include one or moreportions of any of the processor core(s), graphics processor(s), orother accelerator devices described herein. Each unit of logic 2472,2474 can be implemented within a semiconductor die and coupled with thesubstrate 2480 via an interconnect structure 2473. The interconnectstructure 2473 may be configured to route electrical signals between thelogic 2472, 2474 and the substrate 2480, and can include interconnectssuch as, but not limited to bumps or pillars. The interconnect structure2473 may be configured to route electrical signals such as, for example,input/output (I/O) signals and/or power or ground signals associatedwith the operation of the logic 2472, 2474. Optionally, the substrate2480 may be an epoxy-based laminate substrate. The substrate 2480 mayalso include other suitable types of substrates. The package assembly2470 can be connected to other electrical devices via a packageinterconnect 2483. The package interconnect 2483 may be coupled to asurface of the substrate 2480 to route electrical signals to otherelectrical devices, such as a motherboard, other chipset, or multi-chipmodule.

The units of logic 2472, 2474 may be electrically coupled with a bridge2482 that is configured to route electrical signals between the logic2472, 2474. The bridge 2482 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2482 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic 2472, 2474.

Although two units of logic 2472, 2474 and a bridge 2482 areillustrated, embodiments described herein may include more or fewerlogic units on one or more dies. The one or more dies may be connectedby zero or more bridges, as the bridge 2482 may be excluded when thelogic is included on a single die. Alternatively, multiple dies or unitsof logic can be connected by one or more bridges. Additionally, multiplelogic units, dies, and bridges can be connected together in otherpossible configurations, including three-dimensional configurations.

FIG. 24C illustrates a package assembly 2490 that includes multipleunits of hardware logic chiplets connected to a substrate 2480 (e.g.,base die). A graphics processing unit, parallel processor, and/orcompute accelerator as described herein can be composed from diversesilicon chiplets that are separately manufactured. In this context, achiplet is an at least partially packaged integrated circuit thatincludes distinct units of logic that can be assembled with otherchiplets into a larger package. A diverse set of chiplets with differentIP core logic can be assembled into a single device. Additionally thechiplets can be integrated into a base die or base chiplet using activeinterposer technology. The concepts described herein enable theinterconnection and communication between the different forms of IPwithin the GPU. IP cores can be manufactured using different processtechnologies and composed during manufacturing, which avoids thecomplexity of converging multiple IPs, especially on a large SoC withseveral flavors IPs, to the same manufacturing process. Enabling the useof multiple process technologies improves the time to market andprovides a cost-effective way to create multiple product SKUs.Additionally, the disaggregated IPs are more amenable to being powergated independently, components that are not in use on a given workloadcan be powered off, reducing overall power consumption.

In various embodiments a package assembly 2490 can include fewer orgreater number of components and chiplets that are interconnected by afabric 2485 or one or more bridges 2487. The chiplets within the packageassembly 2490 may have a 2.5D arrangement usingChip-on-Wafer-on-Substrate stacking in which multiple dies are stackedside-by-side on a silicon interposer that includes through-silicon vias(TSVs) to couple the chiplets with the substrate 2480, which includeselectrical connections to the package interconnect 2483.

In one embodiment, silicon interposer is an active interposer 2489 thatincludes embedded logic in addition to TSVs. In such embodiment, thechiplets within the package assembly 2490 are arranged using 3D face toface die stacking on top of the active interposer 2489. The activeinterposer 2489 can include hardware logic for I/O 2491, cache memory2492, and other hardware logic 2493, in addition to interconnect fabric2485 and a silicon bridge 2487. The fabric 2485 enables communicationbetween the various logic chiplets 2472, 2474 and the logic 2491, 2493within the active interposer 2489. The fabric 2485 may be an NoCinterconnect or another form of packet switched fabric that switchesdata packets between components of the package assembly. For complexassemblies, the fabric 2485 may be a dedicated chiplet enablescommunication between the various hardware logic of the package assembly2490.

Bridge structures 2487 within the active interposer 2489 may be used tofacilitate a point to point interconnect between, for example, logic orI/O chiplets 2474 and memory chiplets 2475. In some implementations,bridge structures 2487 may also be embedded within the substrate 2480.

The hardware logic chiplets can include special purpose hardware logicchiplets 2472, logic or I/O chiplets 2474, and/or memory chiplets 2475.The hardware logic chiplets 2472 and logic or I/O chiplets 2474 may beimplemented at least partly in configurable logic or fixed-functionalitylogic hardware and can include one or more portions of any of theprocessor core(s), graphics processor(s), parallel processors, or otheraccelerator devices described herein. The memory chiplets 2475 can beDRAM (e.g., GDDR, HBM) memory or cache (SRAM) memory. Cache memory 2492within the active interposer 2489 (or substrate 2480) can act as aglobal cache for the package assembly 2490, part of a distributed globalcache, or as a dedicated cache for the fabric 2485

Each chiplet can be fabricated as separate semiconductor die and coupledwith a base die that is embedded within or coupled with the substrate2480. The coupling with the substrate 2480 can be performed via aninterconnect structure 2473. The interconnect structure 2473 may beconfigured to route electrical signals between the various chiplets andlogic within the substrate 2480. The interconnect structure 2473 caninclude interconnects such as, but not limited to bumps or pillars. Insome embodiments, the interconnect structure 2473 may be configured toroute electrical signals such as, for example, input/output (I/O)signals and/or power or ground signals associated with the operation ofthe logic, I/O and memory chiplets. In one embodiment, an additionalinterconnect structure couples the active interposer 2489 with thesubstrate 2480.

The substrate 2480 may be an epoxy-based laminate substrate, however, itis not limited to that and the substrate 2480 may also include othersuitable types of substrates. The package assembly 2490 can be connectedto other electrical devices via a package interconnect 2483. The packageinterconnect 2483 may be coupled to a surface of the substrate 2480 toroute electrical signals to other electrical devices, such as amotherboard, other chipset, or multi-chip module.

A logic or I/O chiplet 2474 and a memory chiplet 2475 may beelectrically coupled via a bridge 2487 that is configured to routeelectrical signals between the logic or I/O chiplet 2474 and a memorychiplet 2475. The bridge 2487 may be a dense interconnect structure thatprovides a route for electrical signals. The bridge 2487 may include abridge substrate composed of glass or a suitable semiconductor material.Electrical routing features can be formed on the bridge substrate toprovide a chip-to-chip connection between the logic or I/O chiplet 2474and a memory chiplet 2475. The bridge 2487 may also be referred to as asilicon bridge or an interconnect bridge. For example, the bridge 2487is an Embedded Multi-die Interconnect Bridge (EMIB). Alternatively, thebridge 2487 may simply be a direct connection from one chiplet toanother chiplet.

FIG. 24D illustrates a package assembly 2494 including interchangeablechiplets 2495, according to an embodiment. The interchangeable chiplets2495 can be assembled into standardized slots on one or more basechiplets 2496, 2498. The base chiplets 2496, 2498 can be coupled via abridge interconnect 2497, which can be similar to the other bridgeinterconnects described herein and may be, for example, an EMIB. Memorychiplets can also be connected to logic or I/O chiplets via a bridgeinterconnect. I/O and logic chiplets can communicate via an interconnectfabric. The base chiplets can each support one or more slots in astandardized format for one of logic or I/O or memory/cache.

SRAM and power delivery circuits may be fabricated into one or more ofthe base chiplets 2496, 2498, which can be fabricated using a differentprocess technology relative to the interchangeable chiplets 2495 thatare stacked on top of the base chiplets. For example, the base chiplets2496, 2498 can be fabricated using a larger process technology, whilethe interchangeable chiplets can be manufactured using a smaller processtechnology. One or more of the interchangeable chiplets 2495 may bememory (e.g., DRAM) chiplets. Different memory densities can be selectedfor the package assembly 2494 based on the power, and/or performancetargeted for the product that uses the package assembly 2494.Additionally, logic chiplets with a different number of type offunctional units can be selected at time of assembly based on the power,and/or performance targeted for the product. Additionally, chipletscontaining IP logic cores of differing types can be inserted into theinterchangeable chiplet slots, enabling hybrid processor designs thatcan mix and match different technology IP blocks.

Exemplary System on a Chip Integrated Circuit

FIG. 25-26B illustrate exemplary integrated circuits and associatedgraphics processors that may be fabricated using one or more IP cores.In addition to what is illustrated, other logic and circuits may beincluded, including additional graphics processors/cores, peripheralinterface controllers, or general-purpose processor cores. The elementsof FIG. 25-26B having the same or similar names as the elements of anyother figure herein describe the same elements as in the other figures,can operate or function in a manner similar to that, can comprise thesame components, and can be linked to other entities, as those describedelsewhere herein, but are not limited to such.

FIG. 25 is a block diagram illustrating an exemplary system on a chipintegrated circuit 2500 that may be fabricated using one or more IPcores. Exemplary integrated circuit 2500 includes one or moreapplication processor(s) 2505 (e.g., CPUs), at least one graphicsprocessor 2510, which may be a variant of the graphics processor 1408,1508, 2510, or of any graphics processor described herein and may beused in place of any graphics processor described. Therefore, thedisclosure of any features in combination with a graphics processorherein also discloses a corresponding combination with the graphicsprocessor 2510, but is not limited to such. The integrated circuit 2500may additionally include an image processor 2515 and/or a videoprocessor 2520, any of which may be a modular IP core from the same ormultiple different design facilities. Integrated circuit 2500 mayinclude peripheral or bus logic including a USB controller 2525, UARTcontroller 2530, an SPI/SDIO controller 2535, and an I²S/I²C controller2540. Additionally, the integrated circuit can include a display device2545 coupled to one or more of a high-definition multimedia interface(HDMI) controller 2550 and a mobile industry processor interface (MIPI)display interface 2555. Storage may be provided by a flash memorysubsystem 2560 including flash memory and a flash memory controller.Memory interface may be provided via a memory controller 2565 for accessto SDRAM or SRAM memory devices. Some integrated circuits additionallyinclude an embedded security engine 2570.

FIG. 26A-26B are block diagrams illustrating exemplary graphicsprocessors for use within an SoC, according to embodiments describedherein. The graphics processors may be variants of the graphicsprocessor 1408, 1508, 2510, or any other graphics processor describedherein. The graphics processors may be used in place of the graphicsprocessor 1408, 1508, 2510, or any other of the graphics processorsdescribed herein. Therefore, the disclosure of any features incombination with the graphics processor 1408, 1508, 2510, or any otherof the graphics processors described herein also discloses acorresponding combination with the graphics processors of FIG. 26A-26B,but is not limited to such. FIG. 26A illustrates an exemplary graphicsprocessor 2610 of a system on a chip integrated circuit that may befabricated using one or more IP cores, according to an embodiment. FIG.26B illustrates an additional exemplary graphics processor 2640 of asystem on a chip integrated circuit that may be fabricated using one ormore IP cores, according to an embodiment. Graphics processor 2610 ofFIG. 26A is an example of a low power graphics processor core. Graphicsprocessor 2640 of FIG. 26B is an example of a higher performancegraphics processor core. For example, each of graphics processor 2610and graphics processor 2640 can be a variant of the graphics processor2510 of FIG. 25, as mentioned at the outset of this paragraph.

As shown in FIG. 26A, graphics processor 2610 includes a vertexprocessor 2605 and one or more fragment processor(s) 2615A-2615N (e.g.,2615A, 2615B, 2615C, 2615D, through 2615N-1, and 2615N). Graphicsprocessor 2610 can execute different shader programs via separate logic,such that the vertex processor 2605 is optimized to execute operationsfor vertex shader programs, while the one or more fragment processor(s)2615A-2615N execute fragment (e.g., pixel) shading operations forfragment or pixel shader programs. The vertex processor 2605 performsthe vertex processing stage of the 3D graphics pipeline and generatesprimitives and vertex data. The fragment processor(s) 2615A-2615N usethe primitive and vertex data generated by the vertex processor 2605 toproduce a framebuffer that is displayed on a display device. Thefragment processor(s) 2615A-2615N may be optimized to execute fragmentshader programs as provided for in the OpenGL API, which may be used toperform similar operations as a pixel shader program as provided for inthe Direct 3D API.

Graphics processor 2610 additionally includes one or more memorymanagement units (MMUs) 2620A-2620B, cache(s) 2625A-2625B, and circuitinterconnect(s) 2630A-2630B. The one or more MMU(s) 2620A-2620B providefor virtual to physical address mapping for the graphics processor 2610,including for the vertex processor 2605 and/or fragment processor(s)2615A-2615N, which may reference vertex or image/texture data stored inmemory, in addition to vertex or image/texture data stored in the one ormore cache(s) 2625A-2625B. The one or more MMU(s) 2620A-2620B may besynchronized with other MMUs within the system, including one or moreMMUs associated with the one or more application processor(s) 2505,image processor 2515, and/or video processor 2520 of FIG. 25, such thateach processor 2505-2520 can participate in a shared or unified virtualmemory system. Components of graphics processor 2610 may correspond withcomponents of other graphics processors described herein. The one ormore MMU(s) 2620A-2620B may correspond with MMU 245 of FIG. 2C. Vertexprocessor 2605 and fragment processor 2615A-2615N may correspond withgraphics multiprocessor 234. The one or more circuit interconnect(s)2630A-2630B enable graphics processor 2610 to interface with other IPcores within the SoC, either via an internal bus of the SoC or via adirect connection, according to embodiments. The one or more circuitinterconnect(s) 2630A-2630B may correspond with the data crossbar 240 ofFIG. 2C. Further correspondence may be found between analogouscomponents of the graphics processor 2610 and the various graphicsprocessor architectures described herein.

As shown FIG. 26B, graphics processor 2640 includes the one or moreMMU(s) 2620A-2620B, cache(s) 2625A-2625B, and circuit interconnect(s)2630A-2630B of the graphics processor 2610 of FIG. 26A. Graphicsprocessor 2640 includes one or more shader cores 2655A-2655N (e.g.,2655A, 2655B, 2655C, 2655D, 2655E, 2655F, through 2655N-1, and 2655N),which provides for a unified shader core architecture in which a singlecore or type or core can execute all types of programmable shader code,including shader program code to implement vertex shaders, fragmentshaders, and/or compute shaders. The exact number of shader corespresent can vary among embodiments and implementations. Additionally,graphics processor 2640 includes an inter-core task manager 2645, whichacts as a thread dispatcher to dispatch execution threads to one or moreshader cores 2655A-2655N and a tiling unit 2658 to accelerate tilingoperations for tile-based rendering, in which rendering operations for ascene are subdivided in image space, for example to exploit localspatial coherence within a scene or to optimize use of internal caches.Shader cores 2655A-2655N may correspond with, for example, graphicsmultiprocessor 234 as in FIG. 2D, or graphics multiprocessors 325, 350of FIGS. 3A and 3B respectively, or multi-core group 365A of FIG. 3C.

Systolic Arithmetic on Sparse Data

A sparse matrix is a matrix that contains few non-zero elements relativeto the total number of elements in the matrix. The sparsity of a matrixcan be specified by the number of zero-value elements divided by thetotal number of elements. The amount of storage consumed by sparsematrices can be reduce by compressing the data and/or encoding the datainto a sparse encoding format. Processing operations performed usingsparse matrices can be accelerated by bypassing multiplicationoperations on zero-value matrix elements. Optimizations can also beperformed for matrix data that is predominantly any single value or thatotherwise may be easily compressed.

Embodiments described herein include, software, firmware, and hardwarelogic that provides techniques to perform arithmetic on sparse data viaa systolic processing unit or other matrix and/or tensor acceleratorunits. One embodiment provides techniques to optimize training andinference on a systolic array when using sparse data. One embodimentprovides techniques to use decompression information when performingsparse compute operations. One embodiment provides for a numericaltransform to convert sparse data and enable training to be performedbased on the transformed data. One embodiment provides techniques toperform systolic arithmetic directly on compressed data.

GPGPU with Tensor Acceleration Logic

FIG. 27 is a block diagram of a data processing system 2700, accordingto an embodiment. The data processing system 2700 is a heterogeneousprocessing system having a processor 2702, unified memory 2710, and aGPGPU 2720 including machine learning acceleration logic. The processor2702 and the GPGPU 2720 can be any of the processors and GPGPU/parallelprocessors as described herein. The processor 2702 can executeinstructions for a compiler 2715 stored in system memory 2712. Thecompiler 2715 executes on the processor 2702 to compile source code2714A into compiled code 2714B. The compiled code 2714B can includeinstructions that may be executed by the processor 2702 and/orinstructions that may be executed by the GPGPU 2720. During compilation,the compiler 2715 can perform operations to insert metadata, includinghints as to the level of data parallelism present in the compiled code2714B and/or hints regarding the data locality associated with threadsto be dispatched based on the compiled code 2714B. The compiler 2715 caninclude the information necessary to perform such operations or theoperations can be performed with the assistance of a runtime library2716. The runtime library 2716 can also assist the compiler 2715 in thecompilation of the source code 2714A and can also include instructionsthat are linked at runtime with the compiled code 2714B to facilitateexecution of the compiled instructions on the GPGPU 2720.

The unified memory 2710 represents a unified address space that may beaccessed by the processor 2702 and the GPGPU 2720. The unified memorycan include system memory 2712 as well as GPGPU memory 2718. The GPGPUmemory 2718 is memory within an address pace of the GPGPU 2720 and caninclude some or all of system memory 2712. In one embodiment the GPGPUmemory 2718 can also include at least a portion of any memory dedicatedfor use exclusively by the GPGPU 2720. In one embodiment, compiled code2714B stored in system memory 2712 can be mapped into GPGPU memory 2718for access by the GPGPU 2720.

The GPGPU 2720 includes multiple compute blocks 2724A-2724N, which caninclude one or more of a variety of processing resources describedherein. The processing resources can be or include a variety ofdifferent computational resources such as, for example, execution units,compute units, streaming multiprocessors, graphics multiprocessors, ormulti-core groups. In one embodiment the GPGPU 2720 additionallyincludes a tensor accelerator 2723, which can include one or morespecial function compute units that are designed to accelerate a subsetof matrix operations (e.g., dot product, etc.). The tensor accelerator2723 may also be referred to as a tensor accelerator or tensor core. Inone embodiment, logic components within the tensor accelerator 2723 maybe distributed across the processing resources of the multiple computeblocks 2724A-2724N.

The GPGPU 2720 can also include a set of resources that can be shared bythe compute blocks 2724A-2724N and the tensor accelerator 2723,including but not limited to a set of registers 2725, a power andperformance module 2726, and a cache 2727. In one embodiment theregisters 2725 include directly and indirectly accessible registers,where the indirectly accessible registers are optimized for use by thetensor accelerator 2723. The power and performance module 2726 can beconfigured to adjust power delivery and clock frequencies for thecompute blocks 2724A-2724N to power gate idle components within thecompute blocks 2724A-2724N. In various embodiments the cache 2727 caninclude an instruction cache and/or a lower level data cache.

The GPGPU 2720 can additionally include an L3 data cache 2730, which canbe used to cache data accessed from the unified memory 2710 by thetensor accelerator 2723 and/or the compute elements within the computeblocks 2724A-2724N. In one embodiment the L3 data cache 2730 includesshared local memory 2732 that can be shared by the compute elementswithin the compute blocks 2724A-2724N and the tensor accelerator 2723.

In one embodiment the GPGPU 2720 includes instruction handling logic,such as a fetch and decode unit 2721 and a scheduler controller 2722.The fetch and decode unit 2721 includes a fetch unit and decode unit tofetch and decode instructions for execution by one or more of thecompute blocks 2724A-2724N or the tensor accelerator 2723. Theinstructions can be scheduled to the appropriate functional unit withinthe compute block 2724A-2724N or the tensor accelerator via thescheduler controller 2722. In one embodiment the scheduler controller2722 is an ASIC configurable to perform advanced scheduling operations.In one embodiment the scheduler controller 2722 is a micro-controller ora low energy-per-instruction processing core capable of executingscheduler instructions loaded from a firmware module.

In one embodiment some functions to be performed by the compute blocks2724A-2724N can be directly scheduled to or offloaded to the tensoraccelerator 2723. In various embodiments the tensor accelerator 2723includes processing element logic configured to efficiently performmatrix compute operations, such as multiply and add operations and dotproduct operations used by 3D graphics or compute shader programs. Inone embodiment the tensor accelerator 2723 can be configured toaccelerate operations used by machine learning frameworks. In oneembodiment the tensor accelerator 2723 is an application specificintegrated circuit explicitly configured to perform a specific set ofparallel matrix multiplication and/or addition operations. In oneembodiment the tensor accelerator 2723 is a field programmable gatearray (FPGA) that provides fixed function logic that can updated betweenworkloads. The set of matrix operations that can be performed by thetensor accelerator 2723 may be limited relative to the operations thatcan be performed by the compute block 2724A-2724N. However, the tensoraccelerator 2723 can perform those the operations at a significantlyhigher throughput relative to the compute block 2724A-2724N.

FIG. 28 illustrates a matrix operation 2805 performed by an instructionpipeline 2800, according to an embodiment. The instruction pipeline 2800can be configured to perform a matrix operation 2805, such as, but notlimited to a dot product operation. The dot product of two vectors is ascalar value that is equal to sum of products of correspondingcomponents of the vectors. The dot product can be calculated as shown inequation (1) below.

$\begin{matrix}{{\overset{\rightarrow}{a} \cdot \overset{\rightarrow}{b}} = {{\sum\limits_{i = 1}^{n}{a_{i}b_{i}}} = {{a_{1}b_{1}} + \ldots + {a_{n}b_{n}}}}} & (1)\end{matrix}$

The dot product can be used in a convolution operation for aconvolutional neural network (CNN). FIG. 28 illustrates atwo-dimensional (2D) convolution using a matrix operation 2805 includinga dot product operation. While 2D convolution is illustrated,N-dimensional convolution can be performed on an N-dimensional volumeusing N-dimensional filters. A receptive field tile 2802 highlights aportion of an input volume in an input volume buffer 2804. The inputvolume buffer can be stored in memory 2830. A dot matrix operation 2805can be performed between the data within the receptive field tile 2802and a convolutional filter to generate a data point within output buffer2806, which can also be stored in memory 2830. The memory 2830 can beany of the memory described herein, including system memory 2712, GPGPUmemory 2718, or one or more cache memories 2727, 2730 as in FIG. 27.

The combination of the data points within the output buffer 2806represents an activation map generated by the convolution operation.Each point within the activation map is generated by sliding thereceptive field tile across the input volume buffer 2804. The activationmap data can be input to an activation function to determine an outputactivation value. In one embodiment, convolution of the input volumebuffer 2804 can be defined within a framework as high-level matrixoperation 2905. The high-level matrix operations can be performed viaprimitive operations, such as a basic linear algebra subprogram (BLAS)operation. The primitive operations can be accelerated via hardwareinstructions executed by the instruction pipeline 2800.

The instruction pipeline 2800 used to accelerate hardware instructionscan include the instruction fetch and decode unit 2721, which can fetchand decode hardware instructions, and the scheduler controller 2722which can schedule decoded instructions to one or more processingresources within the compute blocks 2724A-2724N and/or the tensoraccelerator 2723. In one embodiment, a hardware instruction can bescheduled to the compute blocks 2724A-2724N and offloaded to the tensoraccelerator 2723. The one or more hardware instructions and associateddata to perform the matrix operation 2805 can be stored in the memory2830. Output of the hardware instruction can also be stored in thememory 2830.

In one embodiment, the tensor accelerator 2723 can execute one or morehardware instructions to perform the matrix operation 2805 using anintegrated systolic tensor array 2808 (DP logic). The systolic tensorarray 2808 can include a combination of programmable and fixed functionhardware that is configurable to perform dot product operations. Whilefunctional units within the compute blocks 2724A-2724N can also beconfigured to perform dot product operations, the systolic tensor array2808 can be configured to perform a limited subset of dot productoperations at a significantly higher throughput relative to the computeblock 2724A-2724N.

FIG. 29A-29B illustrate details of hardware-based systolic tensor array2808, according to some embodiments. FIG. 29A illustrates a grid ofmultiple functional units that are configurable to perform multiple dotproduct operations within a single clock cycle. FIG. 29B illustrates asingle exemplary functional unit.

As shown in FIG. 29A, in one embodiment the systolic tensor array 2808is configurable to perform a set of parallel dot product operationsusing a variety of functional units. The dot products can be performedin a ‘systolic’ manner, in which SIMD data is pumped across multiplelayers of functional units. The systolic tensor array 2808 is acollection of functional units that are arranged in a grid. The grid offunctional units work in lockstep and are optimized to performmultiply-accumulate operations. Matrices to be operated on by thesystolic tensor array 2808 are divided in to sub-matrices, which arepumped across the grid of functional units.

In one embodiment the systolic tensor array 2808 can process aconfigurable number of SIMD channels of data using a configurablesystolic depth. For a given instruction, a SIMD width and a systolicdepth can be selected to process a set of source data. The systolicdepth defines the number of systolic layers of hardware logic that willbe used to process an instruction. A systolic layer is a group ofmultiplier and adder logic units having a variable SIMD width, where thesystolic layer can receive, as input, an initial accumulator value andgenerates a dot product value for output to a successive systolic layeror to an output register.

In some embodiments, three sources can be processed, where each sourcecan be a vector register or an immediate. In one embodiment, source 2900(SRC0) can be one or more initial accumulator values, which can be asingle value or a vector of accumulator values. The initial accumulatorvalue will be added to the first set of dot products computed by eachfunctional unit within the first systolic layer. The dot productcomputed by a functional unit can be provided to the next systolic layerfor the given SIMD channel. The dot products can be computed based onsource 2901 (SRC1) and source 2902 (SRC2), which are vector registersthat can contain one more channels of packed data, each channelcontaining a four-element vector. In one embodiment, each channel is32-bits wide and provides four, 8-bit vector elements. Some embodimentsare configurable to calculate dot products from input vectors having8-bit elements, 4-bit elements, and/or 2-bit elements. In oneembodiment, mixed precision operations can be performed using anycombination of supported element sizes (e.g., 8-bit×2-bit, 8-bit×4-bit,4-bit×4-bit, etc.). In one embodiment, the systolic tensor array 2808 isconfigured for integer calculation, although automatic fixed-pointoperation is configurable in some embodiments. Although the instructiondescribed herein is a four-element dot product, in some embodiments thesystolic tensor array 2808 may also be configured to supportfloating-point dot-product calculations on a different number ofelements per vector.

In one embodiment, multiple channels of four-element vectors can bepacked into a single vector register of various widths (e.g., 64-bit,128-bit, 256-bit, 512-bit, etc.). Simultaneous dot products can becomputed via the systolic tensor array 2808 for multiple channels ofvector elements provided via source 2901 and source 2902. The number ofchannels of vector elements to be processed can be configured based on aselected execution size and systolic depth for the dot productcalculation. In one embodiment, source vectors that are wider than thespecified execution size and/or systolic depth may be calculated usingmultiple cycles of the systolic tensor array 2808.

The number of calculations that can be performed within a given clockcycle can vary based on the number of SIMD lanes and systolic layers.The systolic tensor array 2808, as illustrated, can perform sixteen dotproducts per SIMD lane of throughput using a systolic depth of four. Ifconfigured for eight SIMD lanes, the logic can perform 128 eight-bitinteger (INT8) dot products within a given cycle. If configured foreight SIMD lanes and a systolic depth of eight, each lane can perform 32eight-bit integer (INT8) dot products and 256 dot products in total.These specific number of operations are exemplary of one embodiment, andother embodiments vary in throughput. Furthermore, if the data types aredifferent, then the number of operations will be scaled based on thedifferent data types.

At each functional unit, a dot product is computed via multiplier andadder logic and the dot product is added to an accumulator value. Theresulting data can be output to a destination register or provide to theaccumulator of the next systolic layer. Details of a functional unit2912 are shown in FIG. 29B.

As shown in FIG. 29B a functional unit 2912 can include a set of inputdata buffers 2904, 2906 and an accumulator 2922, which can each acceptinput data. In one embodiment, data buffer 2906 can accept source 2902,(SRC2), which can be a packed vector of input data. Input data buffer2904 can accept a source 2901 (SRC1), which can also be a packed vectorof input data. The accumulator 2922 can accept source 2900 (SRC0) thatprovides an initial accumulator value for the functional unit 2912. Theinitial accumulator value is added to the dot product computed from theelements of source 2901 and source 2902. The dot product is computed viaan element-wise multiplication of the source vectors using a set ofmultipliers 2923A-2923D and an adder 2924. The multipliers 2923A-2923Dare used to compute a set of products. A sum of the set of products iscomputed by the adder 2924. The sum can be accumulated with (e.g., addedto) any initial value provided via source 2900. In one embodiment, thisaccumulated value can be provided as an input value 2926 to the nextaccumulator, which can reside in a subsequent systolic layer. In oneembodiment, source 2901 may include multiple channels of input data.Additional channels of source 2901 can be relayed as SRC1 input toadditional SIMD lanes 2928. In one embodiment, source 2902 may includemultiple channels of input data. Additional channels of source 2902 canbe used as SRC2 input data to logic units within additional systolicdepths. In one embodiment, source 2900 can optionally include multiplechannels, with additional channels provided as input to the accumulatorwithin additional functional units. In one embodiment, source 2900 canbe a single value that is added to each accumulator in each functionalunit of the initial systolic layer.

FIG. 30 illustrates a processing resource 3000 including a systolictensor array with sparse optimizations, according to an embodiment. Theprocessing resource 3000 includes similar components as the executionunit 1900, along with a tensor accelerator 3012 having sparseoptimizations. Variants of the processing resource 3000 may be used in aparallel compute accelerator, a graphics processing engine and/or aneural network accelerator. The tensor accelerator 3012 can include asystolic tensor array 2808 as in FIG. 28 or a systolic array 1912 as inFIG. 19 and have similar functionality. Other matrix accelerationarchitectures may also be used. The sparse optimizations of the tensoraccelerator 3012 are detailed below.

Optimized Training and Inference on a Systolic Array when Using SparseData

One embodiment provides techniques to optimize training and inference ona systolic array when using sparse data. If a submatrix to be processedby the systolic tensor array 2808 is entirely zero, a dimension valuefor the submatrix can be set to zero and the systolic tensor array 2808may bypass one or more computational phases associated with thesubmatrix depending on the operation to be performed. Duringpre-processing of matrix data, zero submatrices can be identified and asubmatrix map for the matrix can be generated to indicate whichsubmatrices include only zero values. In one embodiment, submatricesthat include only one non-zero value can also be bypassed.

FIG. 31A-31B illustrates a system to bypass zero value submatrices,according to embodiments. As shown in FIG. 31A, matrix 3102 and matrix3104 are matrices in which one or more submatrices contain only zerovalues. Processing logic can generate submatrix map 3112 for matrix 3102and submatrix map 3114 for matrix 3104 to indicate whether a submatrixcontains only zero values. The submap can be generated using a varietyof techniques, including performing a bitwise comparison to zero foreach submatrix. The submatrix maps can be generated by framework ordriver logic that execute on general purpose processing logic (e.g.,CPUs) or can be generated by dedicated hardware logic within theprocessing resources.

In one embodiment, a single non-zero value submatrix 3105 that includesa single non-zero value can also be bypassed, as a result of the matrixoperation can be computed using an ALU instead of the systolic tensorarray.

As shown in FIG. 31B, a memory 3120 can store matrix 3102 and matrix3104. The systolic tensor array 2808 can include a matrix A load unit3126, matrix B load unit 3122, a matrix A feed unit 3128, and matrix Bfeed unit 3124. Matrix 3102 can be loaded and fed as matrix B, whilematrix 3104 can be loaded and fed as matrix A. Submatrices of matrix Aand matrix B can be loaded and fed through the functional units 3130that operate as the processing elements of the systolic tensor array2808.

In one embodiment a load B filter 3127 and load A filter 2127 caninclude a buffer to store the submatrix map 3112 for matrix 3102 andsubmatrix map 3114 for matrix 3104. The load B filter 3121 can bypassthe load of zero value submatrices by the matrix B load unit 3122. Theload A filter 3127 can bypass the load of zero value submatrices by thematrix A load unit 3126. Submatrices that are not bypassed can beprocessed by the functional units 3130. Depending on the operation to beperformed by the systolic tensor array 2808, where one of thesubmatrices is zero, the entire operation can be bypassed. When thesubmatrix includes a single non-zero value submatrix the submatricesassociated with the operation to be performed can bypass the systolictensor array 2808 and the operation can be performed by an ALU.

FIG. 32 illustrates a compute resource 3010 including logic to bypassthe systolic tensor array 2808 for operations on a submatrix thatinclude a single non-zero value. Elements of matrix 3102 and matrix 3104that are stored in the memory 3120 can be loaded into the register file3006 of the compute resource 3010. The tensor accelerator 3012 caninclude logic to transmit a submatrix bypass message 3202 to the ALU3011 that indicates the registers that store bypassed submatrix data3204 and the bypassed operation to be performed. The ALU 3011 can thenperformed the bypassed operation using vector processing logic. Theprocessing of the bypassed operation can be performed in parallel withthe non-bypassed operations performed by the tensor accelerator 3012.

Using Decompression Information when Performing Sparse ComputeOperations

FIG. 33 illustrates a compute architecture 3300 configured to enablecompressed transmission of neural network data to processing resourceson a parallel compute processor or general purpose graphics processingunit, according to an embodiment. The compute architecture 3300includes, in one embodiment, a compute block 3302 and hardware scratchbuffer 3304 that is coupled to memory 3308 via a DMA controller 3306.The memory 3308 can be main memory or system memory of a data processingsystem. The compute block 3302 includes a set of processing resources asdescribed herein and can be similar to any of the compute blocks2724A-2724N as in FIG. 27. The scratch buffer 3304 can be a high-speedon-chip memory, such as on-chip static random access memory (SRAM). Inone embodiment the scratch buffer 3304 is optimized to store featureblock units or kernel block units for neural network operationsperformed by the compute block 3302.

In one embodiment the decoder 3312 can be hardware decoder logic that isintegrated into the compute block 3302 to enable compressed transmissionof neural network data across the compute architecture. For example,when processing a CNN, the compute block 3302 can generate outputfeature map (OFM) data in the scratch buffer 3304 in an uncompressedformat. An encoder 3316 integrated into the DMA controller 3306 toenable the writing the output feature maps data to the memory 3308 in acompressed format. When the OFM of one layer become the input featuremap (IFM) of the next layer, those IFMs are read from memory 3308 ascompressed data 3314 and stored in the scratch buffer 3304. The decoder3312 can enable the compute block 3302 to read in the compressed data3314 without requiring the data to be decoded. Alternatively, a codecunit having both encode and decode logic can be integrated into the DMAcontroller 3306, enabling compressed data to be transmitted and read bythe DMA controller 3306. The feature map data can then be decompressedby the DMA controller 3306 and written to the scratch buffer 3304 in anuncompressed format to be read by the compute block 3302.

In the embodiments described herein, the specific encoding format forkernel and feature data can be varied based on the statistics of thedata to be encoded. Analysis of neural network feature map dataindicates that many feature maps may be highly sparse. Analysis ofneural network kernel data indicates that while the kernel data is notas sparse as the feature map data, many values in the kernel data arerepeated. The dynamic range of kernel data is relatively low, whichindicates that raw data allocate more bits than required to store thecoefficients. Using varied encoding techniques feature map and kerneldata can be compressed by as much as 80% in a lossless manner using aselection of various encoding techniques.

Neural network related data can be encoded (e.g., compressed) using avariety of encoding techniques, such as but not limited to uniqueabsolute value (UAV) table encoding, significance map (SM) encoding,table encoding (TE), unique value coordinate (UVC) encoding, and meanencoding (ME). Metadata for the encoded data indicates the type ofencoding format used for the data. In one embodiment, specific encodingformats can be selected for specific types of data, such as kernel dataor feature data. In one embodiment, statistical analysis is performed onthe data prior to encoding to enable an appropriate encoder to beselected for each block of data.

In one embodiment data generated during SM encoding can be used tofacilitate submatrix bypass within a systolic tensor array. In SMencoding mode, only non-zero values in a block are encoded. The numberof non-zero values in a sample block is indicated in the header,followed by a significance map indicating a map of the non-zero valueswithin the block. The non-zero values of the sample are then encoded inorder of appearance within the stream.

FIG. 34A-34B illustrates significance map encoding for sparse neuralnetwork data, according to embodiments. FIG. 34A illustrates an encodinglayout 3420 for SM encoding. FIG. 34B illustrates decode of an exemplarybit stream significance map encoded bit stream.

As shown in FIG. 34A, an encoding layout 3420 enables sample blocks ofsparse neural network data to encoded in a reduced-bit format thatreduces the amount of data that is required to be transmitted or storedwhen processing neural networks associated with the data. In theillustrated encoding layout 3420, the number of non-zero values in asample block is indicated in a header 3422, followed by a significancemap 3424 indicating a map of the non-zero values within the block. Thenon-zero values 3426 of the sample are encoded in order of appearancewithin the stream.

As shown in FIG. 34B, encoded bitstream data can be decoded based onsignificance map data. In one embodiment, SM encoding mode data ispresented beginning with the third byte after a two-byte header, wherethe presence of SM encoding is indicated by the first bit of a bitstream header (not shown) at the beginning of an encoded stream of data.The number of non-zero values in a sample block is indicated in theheader 3422. In one embodiment, encoding format can change on aper-sample block basis, so the header 3422 can also include metadatathat indicates SM encoding is enabled for the upcoming block of samples.A significance map 3424 indicates a map of the non-zero values withinthe sample block, with a one-bit entry associated with each value. Thenon-zero values 3426 of the sample are then encoded in order ofappearance within the stream. To decode significance map data into theexemplary decoded bit stream 3430, decoder logic can initialize at leasta portion of an output data buffer 3410 to zero. The decoder logic canthen reference the significance map 3424 to determine which value in thebit stream are non-zero. The non-zero values can be unpackedsequentially and written to locations in the output data buffer 3410indicated by the significance map. For example, a value of zero (0b0) inthe significance map 3424 indicates that the corresponding decoded valueis zero. A value of one (0b1) in the significance map 3424 indicatesthat the corresponding decoded value corresponds to the next successiveentry in the non-zero values 3426 in the encoded bit stream.

FIG. 35 illustrates the use of significance map data to facilitate thebypassing or clock/power gating of elements of a systolic tensor array.In one embodiment a decoder 3312 within a compute block 3302 can providethe significance map 3506 for decompressed data 3508 that was encodedusing significance map encoding. In one embodiment, the decoder cangenerate the significance map 3506 for data that was encoded using adifferent (non-significance map) encoding. The significance map 3506 anddecompressed data 3508 can be provided by the decoder 3312 to aprocessing resource 3000 within the compute block 3404. Bypass/gatelogic 3510 within the systolic tensor array 2808 can determine to bypasssubmatrices within the decompressed data 3508 and/or clock gate certainprocessing elements within the systolic tensor array based on the degreeof sparsity indicated by the significance map 3506 and/or the specificzero and non-zero elements specified by the significance map 3506.

Converting Sparse Data Using Numerical Transforms

In one embodiment, training is expanded to include transformation ofweights to compact non-zero coefficients in the same region to reduceconsumption of memory bandwidth. The training system can test severaldifferent transforms such as a discrete cosine transform (DCT), discretesign transform (DST), bit-flip transforms, bit-rotate transforms, orother types of transforms (e.g., discrete Fourier transforms (DFT),etc.). The training system can select the transform that results in theclosest clustering of non-zero coefficients and/or the highestcompression ratio when compressing the training data. In one embodimentthe training system can select the transform that transforms irregularsparsity into structured or block sparsity. The selected transform modeis signaled within the trained model. The transformed trained model isprovided to inference deployments. The appropriate inverse transform isapplied by the inference system.

FIG. 36 illustrates a system 3600 to transform neural network data tocompact non-zero coefficients, according to an embodiment. System 3600includes a training system 3602, a transform system 3604, inversetransform system 3608, and an inference system 3610. The training system3602 and transform system 3604 can reside on one computing device or acluster of multiple computing devices. The inverse transform system 3608and inference system 3610 may reside on a separate computing device orcluster of computing devices. The components of the system 3600 may alsoreside on a single computing system or computing cluster that performsboth training and inference operations, such as a datacenter-basedcomputing system that performs cloud-based training and inference.

A single computing system or computing cluster may also be used wheremodel re-training or updating is to be performed. Weights for a trainedmodel may be stored in a transformed and compressed state. When a modelis to be re-trained or updated, the weights can be decompressed, aninverse transform can be applied to those weights, and re-training orupdating can be performed to generate an updated set of weights. Thatupdated set of weights may then be re-transformed and re-compressed forstorage or deployment to an inferencing system.

In one embodiment the training system 3602, which can include a tensoraccelerator (e.g., tensor accelerator 2723 as in FIG. 27) as describedherein, can generate a matrix of weights 3603 as a result of trainingoperations performed on a neural network. The matrix of weights can beprocessed by the transform system 3604. The transform system 3604 candetermine a transform type to apply to the matrix of weights 3603. Thetransform system can then output a set of transformed weights 3607 andthe transform type 3605 applied to those transformed weights. The set oftransformed weights 3607 can then be compressed or encoded for storageor for transmission. The transformation is performed such that set oftransformed weights 3607 compresses to a higher compression ratio thanthe original matrix of weights 3603. The higher compression ratio towhich the set of transformed weights 3607 may be compressed may be dueto a higher degree of sparsity that is present in the set of transformedweights 3607 or due to a transformation from irregular sparsity tostructured or block sparsity. Structured or block sparsity and/or ahigher degree of sparsity can also improve the efficiency to which asparse transformed matrix may be encoded in a sparse encoding format,(e.g., coordinate list encoding (COO), compressed sparse row (CSR),compress sparse column (CSC), etc.). In one embodiment, a sparse matrixof transformed weights may be both encoded in a sparse encoding formatand compressed into a compressed encoded format.

The transformed weights 3607 and transform type 3605 can be stored foruse by a computing system that is configured to perform inferenceoperations. Where the transformed weights 3607 are compressed, thetransformed weights may be decompressed before the inverse transform isapplied by the inverse transform system 3608. The inverse transformsystem 3608 can perform an inverse transform operation on thetransformed weights 3607 based on the indicated transform type 3605. Theinverse transform system 3608 can output a matrix of weights 3609 to theinference system 3610 to perform inference operations based on inputdata.

FIG. 37A-37B illustrates logic units to perform transformations andinverse transformations on sparse neural network data. FIG. 37Aillustrates logic units of the transform system 3604. FIG. 37Billustrates logic units of the inverse transform system 3608. Thetransform system 3604 and inverse transform system 3608 can each includeinternal memory and/or couple with memory of a computing device orcomputing system in which the transform system 3604 and inversetransform system 3608 are included.

As shown in FIG. 37A, the transform system 3604 can include a memory3701, a transform selector 3702 and a set of transform logic units3704A-3704N. The set of transform logic units 3704A-3704N can includehardware or firmware logic to perform, for example, DCT, DST, bit-flip,bit-rotate, or other transforms (e.g., DFT, etc.). For the DCT transforma lossless transform is used. However, in some configurations, a lossyDCT may be applied for if the accuracy of the model is not significantlyimpacted. In one embodiment, the set of transform logic units3704A-3704N are implemented as GPGPU executable program code in the formof compute shader or CUDA kernels that may be executed by a GPGPUdescribed herein.

The transform test logic 3703 can load representative samples of thematrix of weights 3603 into memory 3701 and test the samples todetermine a transform that results in the highest degree of sparsity,the closest clustering of non-zero coefficients, and/or the highestcompression ratio when the training data is compressed. In oneembodiment, the transform test logic 3703 can analyze transform testdata and develop metrics related on the distance between non-zero valueswithin the test transform data. In one embodiment, the transform testlogic 3703 can also analyze test transform data to determine metrics onthe potential compression ratios, sparsity level, or sparsity pattern ofthe transformed data. In embodiments in which compression ratio is usedas a quality metric when comparing transformations, the transform testlogic 3703 can include logic to perform a compression test on thetransformed data. The transform test logic can also determine if thereis no transform that will produce the intended result. In such scenario,transformation may be bypassed depending on the system configuration.

Once an optimal transform is determined, the transform test logic 3703can then send a recommendation to the transform selector 3702 as towhich unit in the set of transform logic units 3704A-3704N to use totransform the matrix of weights into transformed weights 3607. In oneembodiment, the transform test logic 3703 can be configured to generatea transform recommendation without applying the transform to the matrixdata. In such embodiment, the transform test logic 3703 can providemetrics associated with the numerical transform tests along with atransformation recommendation. Further in such embodiment, whentransformation is enabled, the transform selector 3702 may also considertest metrics generated by the transform test logic 3703. The transformselector 3702 may then select a transform other than the recommendedtransform under certain circumstances. For example, if the metricsindicate that, for example, the improvement in compression ratio isbelow a threshold, the transformation may be bypassed. The threshold canvary based a current processor status (e.g., thermal load, availablebandwidth, etc.). In one embodiment, the transform test logic 3703 isbypassed if the transform system 3604 is instructed to apply a specifictransform.

In one embodiment, different transforms can be used for sub-matrices ofa weight matrix. For example, if the transform test logic determinesthat a first portion of a weight matrix would have the highestcompression ratio if transformed using a first transformation, while asecond portion of the weight matrix would have the highest compressionratio if transformed using a second transformation, the first transformcan be applied to the first portion, while the second transform can beapplied to the second portion. Where multiple different transforms areused for a weight matrix, the transform type 3605 can be a matrix orbitfield that indicates which transform type is used for a correspondingweight sub-matrix. In some embodiments, multiple transforms may also beapplied to the same sub-matrix or the weight matrix as a whole.

As shown in FIG. 37B, the inverse transform system 3608 includes aninverse transform selector 3712 and a set of inverse transform logicunits 3714A-3714N. The set of inverse transform logic units 3714A-3714Ncan include hardware or firmware logic to perform inversetransformations of the transformations performed by the set of transformlogic units 3704A-3704N of the transform system 3604. In one embodiment,the set of inverse transform logic units 3714A-3714N are implemented asGPGPU executable program code in the form of compute shader or CUDAkernels that may be executed by a GPGPU described herein.

The inverse transform selector 3712 can read the transform type 3605applied to the transformed weights 3607 and perform an inverse transformusing the appropriate inverse transform unit in the set of inversetransform logic units 3714A-3714N to generate a matrix of weights 3609.Inverse transformation is performed according to the transform type 3605that is associated with the transformed weights 3607. Where thetransform type 3605 indicates different transforms have been applied todifferent sub-matrices of the transformed weights 3607, differentinverse transformations are applied to the different portion. Whenmultiple transforms are applied to a sub-matrix or the weight matrix asa whole, multiple inverse transforms are applied.

FIG. 38A-38B illustrate methods 3800, 3820 of generating and usingtransformed matrices on a graphics processor. FIG. 38A illustrates amethod 3800 of performing a matrix transformation. FIG. 38B illustratesa method 3820 of processing a transformed matrix. The transformed matrixdata can be, for example, the transformed weight data output by thetransform system 3604 shown in FIG. 36 and FIG. 37A. The transformedmatrix data can be encoded into a sparse encoding format. In oneembodiment, the sparse encoding format may additionally be compressedusing data compression logic. An inverse transform system 3608 shown inFIG. 36 and FIG. 37B can be used to apply an inverse transform to thematrix data before processing operations are performed using the data.

As shown in FIG. 38A, method 3800 includes for a computing device toload matrix data into a memory within a graphics processor (3802). Thematrix data can be loaded into main graphics memory and a portion of thematrix data can be loaded into an on-die memory of the graphicsprocessor. The on die memory may be local to transformation logic withinthe graphics processor, such as logic associated with the transformsystem 3604.

In one embodiment a specific transform can be specified for the matrixdata. For example, a specific transform is known to be optimal for thematrix data, that transform can be applied, bypassing the transform testlogic. If a specific transform is specified for the matrix data (3803,YES), the computing device can apply the specified transform (3806). Oneor more transforms may be specified. If no transform is specified (3803,NO), then transform test logic 3703 may be used to determine an optimaltransform (3804). In one embodiment the optimal transform for the matrixdata is the transform that is determined to result in the highest degreeof sparsity for the matrix data. In one embodiment the optimal transformis the transform that results in the closest clustering of non-zerocoefficients. In one embodiment the optimal transform is the transformthat results in the highest compression ratio when compressing thetraining data. The determined transform can then be applied to thematrix data via numerical transform logic (3806). The transformed matrixdata can then be encoded and/or compressed (3808). Encoding andcompression can be performed by the computing device using the graphicsprocessor or via software executed on the host computing device. Whereencoding and compression is performed using the graphics processor, theencoding and compression can be performed using hardware encoders orcodecs of the graphics processor or via a shader or compute programexecuted on the graphics processor.

As shown in FIG. 38B, method 3820 includes for a computing device toread a compressed and/or encoded and transformed matrix data from memory(3822). The memory can be a memory of a graphics processor, systemnon-volatile storage, or non-volatile storage memory of a graphicsprocessor. Metadata associated with the matrix data can be read toindicate the compression and/or encoding that has been applied to thetransformed matrix data and the transform that was applied to the matrixdata before compression. Using the compression and/or encoding metadata,the computing device can decompress and/or decode the transformed matrixdata (3824). The computing device, via a graphics processor, can thenapply one or more inverse transforms to the transformed matrix databased on the transformation metadata (3826).

The computing device can use special purpose logic within the graphicsprocessor to decompress or decode the transformed matrix data. Thecomputing device can also use a program executed on the host processoror the graphics processor to decompress or decode the transformed matrixdata. In one embodiment program code that executes on the graphicsprocessor can read compressed and/or encoded and transformed data storedin memory and the graphics processor can automatically decompress and/ordecode the data and apply an inverse transform to the data before thedata is provided to processing units within the graphics processor. Theprocessing units within the graphics processor can then perform computeoperations on the matrix data to generate output data (3828). The outputdata generated by the processing units can then be written to memorywithin the graphics processor or to system memory. In one embodiment thesystem can be configured to automatically apply a transform to theoutput data if a desired characteristic of the output data (e.g.,compression ratio, sparsity characteristics) will be increased (3830).

Performing Systolic Arithmetic on Compressed Data.

In one embodiment, instead of uncompressing data before processing thedata using the systolic tensor array 2808, in one embodiment thesystolic pipe receives input in a compressed or encoded format alongwith metadata that describes how the data is compressed or encoded. Theoutput from the systolic tensor array 2808 can also be compressed andwritten to memory in a compressed format. In one embodiment, compressionand decompression can also include applying transformation and inversetransformation techniques described herein to increase the compressionratio to which data may be compressed.

FIG. 39 illustrates a version of the systolic tensor array 2808 that isconfigured to operate on compressed or encoded data. In one embodimentthe systolic tensor array 2808 includes a decoder 3312 that receivescompressed or encoded data and associated metadata 3902. The decoder3312 can decode the compressed or encoded data based on the metadata togenerate decompressed data 3508 and a significance map 3506. Bypass/gatelogic 3510 can determine to bypass submatrices within the decompresseddata 3508 and/or clock gate certain processing elements of theprocessing units 3910 within the systolic tensor array 2808 based on thedegree of sparsity indicated by the significance map 3506 and/or thespecific zero and non-zero elements specified by the significance map3506. Data output by the processing units 3910 can be compressed orencoded by an encoder 3920 and output as compressed or encoded data withassociated metadata 3928. In one embodiment, the encoder 3920 caninclude numerical transformation logic of the transform system 3604 ofFIG. 37A and the decoder 3312 can include inverse transformation logicof the inverse transform system 3608 of FIG. 37B. In such embodiment,the metadata will also indicate a transformation type for the encodeddata.

FIG. 40 illustrates a method 4000 of performing systolic arithmetic oncompressed or encoded data. The method 4000 can be performed by hardwareor firmware logic described herein. In one embodiment the hardware orfirmware logic can be controlled by software logic, such as driverlogic, that executes on a general purpose processor.

Method 4000 includes for a computing system to perform operations thatinclude to read compressed and/or encoded data from memory (block 4002).The computing system can then load or feed the compressed and/or encodeddata to a tensor accelerator pipeline (block 4004). The tensoraccelerator pipeline can be a systolic pipeline described herein, suchas the systolic tensor array 2808, or another matrix acceleratorarchitecture.

The computing system can then perform compute operations on thecompressed and/or encoded data (block 4006). The compute operations canbe performed based on program code instructions that are executed by thecomputing system, such as a pixel shader, vertex shader, compute shader,or CUDA program. Decode logic associated with processing units of agraphics processor within the computing system can automaticallydecompress and/or decode the compressed and/or encoded data. Forexample, decompression and/or decoding can be performed in concert witha load operation performed by the processing units. In one embodimentthe compression or encoding of the compressed and/or encoded data caninclude one or more numerical transformations that are applied toincrease the compression ratio to which the data may be compressed. Insuch embodiment, decompression and/or decoding includes applying anumerical inverse transform to the data. The numerical transform andnumerical inverse transforms are in addition to any transformations orinverse transformations that are specified by the encoding algorithmapplied to the data.

The computing system can then compress and/or encode output of thetensor accelerator pipeline (block 4008). Compression and/or encodingcan be performed automatically, for example, in concert with a storeoperation performed by processing units of a graphics processor withinthe computing system. In one embodiment, numerical transforms may beapplied before compressing and/or encoding the data, according totechniques described in FIG. 36-38B. The computing system can then writethe compressed and/or encoded output to memory (block 4010). Operationsof the method can be implemented via instructions stored in anon-transitory machine readable medium, based on firmware within amicrocontroller of the computing system, or based on hardware logicwithin the computing system.

Additional Exemplary Computing Device Including a Graphics Processor

FIG. 41 is a block diagram of a computing device 4100 including agraphics processor 4104, according to an embodiment. The computingdevice 4100 can be a computing device including any data processingsystem or subsystem described herein. The computing device 4100 may alsobe or be included within a communication device such as a set-top box(e.g., Internet-based cable television set-top boxes, etc.), globalpositioning system (GPS)-based devices, etc. The computing device 4100may also be or be included within mobile computing devices such ascellular phones, smartphones, personal digital assistants (PDAs), tabletcomputers, laptop computers, e-readers, smart televisions, televisionplatforms, wearable devices (e.g., glasses, watches, bracelets,smartcards, jewelry, clothing items, etc.), media players, etc. Forexample, in one embodiment, the computing device 4100 includes a mobilecomputing device employing an integrated circuit (“IC”), such as systemon a chip (“SoC” or “SOC”), integrating various hardware and/or softwarecomponents of computing device 4100 on a single chip.

The computing device 4100 includes a graphics processor 4104. Thegraphics processor 4104 represents any graphics processor describedherein. The graphics processor includes one or more graphics engine(s),graphics processor cores, and other graphics execution resources asdescribed herein. Such graphics execution resources can be presented inthe forms including but not limited to execution units, shader engines,fragment processors, vertex processors, streaming multiprocessors,graphics processor clusters, or any collection of computing resourcessuitable for the processing of graphics resources or image resources, orperforming general purpose computational operations in a heterogeneousprocessor.

In one embodiment, the graphics processor 4104 includes a cache 4114,which can be a single cache or divided into multiple segments of cachememory, including but not limited to any number of L1, L2, L3, or L4caches, render caches, depth caches, sampler caches, and/or shader unitcaches. In some embodiments, the graphics processor 4104 includes aGPGPU engine 4144 that includes a workload handler 4140, a tensoraccelerator 4134 and transform/inverse transform logic 4124. Theworkload handler 4140 can schedule workload operations for execution onthe tensor accelerator 4134 and the GPGPU engine 4144. The workload unit4124 can have hardware logic units including, but not limited to thescheduler controller 2722 of FIG. 27. The tensor accelerator 4134, inone embodiment, includes or is a version of the tensor accelerator 2723as in FIG. 27. In one embodiment the tensor accelerator 4134 can includea systolic tensor array (e.g., systolic tensor array 2808) as describedherein.

As illustrated, in one embodiment, and in addition to the graphicsprocessor 4104, the computing device 4100 may further include any numberand type of hardware components and/or software components, including,but not limited to an application processor 4106, memory 4108, andinput/output (I/O) sources 4110. The application processor 4106 caninteract with a hardware graphics pipeline to share graphics pipelinefunctionality. Processed data is stored in a buffer in the hardwaregraphics pipeline and state information is stored in memory 4108. Theresulting data can be transferred to a display controller for output viaa display device, such as the display device 1618 of FIG. 16B. Thedisplay device may be of various types, such as Cathode Ray Tube (CRT),Thin Film Transistor (TFT), Liquid Crystal Display (LCD), Organic LightEmitting Diode (OLED) array, etc., and may be configured to displayinformation to a user via a graphical user interface.

The application processor 4106 can include one or more processors, suchas processor(s) 102 of FIG. 1 and may be the central processing unit(CPU) that is used at least in part to execute an operating system (OS)4102 for the computing device 4100. The OS 4102 can serve as aninterface between hardware and/or physical resources of the computingdevice 4100 and one or more users. The OS 4102 can include driver logicfor various hardware devices in the computing device 4100, includinggraphics driver logic 4122, such as the user mode graphics driver 2326and/or kernel mode graphics driver 2329 of FIG. 23.

It is contemplated that in some embodiments the graphics processor 4104may exist as part of the application processor 4106 (such as part of aphysical CPU package) in which case, at least a portion of the memory4108 may be shared by the application processor 4106 and graphicsprocessor 4104, although at least a portion of the memory 4108 may beexclusive to the graphics processor 4104, or the graphics processor 4104may have a separate store of memory. The memory 4108 may comprise apre-allocated region of a buffer (e.g., framebuffer); however, it shouldbe understood by one of ordinary skill in the art that the embodimentsare not so limited, and that any memory accessible to the lower graphicspipeline may be used. The memory 4108 may include various forms ofrandom access memory (RAM) (e.g., SDRAM, SRAM, etc.) comprising anapplication that makes use of the graphics processor 4104 to render adesktop or 3D graphics scene.

A memory controller hub, such as memory controller 1416 of FIG. 14, mayaccess data in the memory 4108 and forward it to graphics processor 4104for graphics pipeline processing. The memory 4108 may be made availableto other components within the computing device 4100. For example, anydata (e.g., input graphics data) received from various I/O sources 4110of the computing device 4100 can be temporarily queued into memory 4108prior to their being operated upon by one or more processor(s) (e.g.,application processor 4106) in the implementation of a software programor application. Similarly, data that a software program determinesshould be sent from the computing device 4100 to an outside entitythrough one of the computing system interfaces, or stored into aninternal storage element, is often temporarily queued in memory 4108prior to its being transmitted or stored.

The I/O sources can include devices such as touchscreens, touch panels,touch pads, virtual or regular keyboards, virtual or regular mice,ports, connectors, network devices, or the like, and can attach via aplatform controller hub 1430 as referenced in FIG. 14. Additionally, theI/O sources 4110 may include one or more I/O devices that areimplemented for transferring data to and/or from the computing device4100 (e.g., a networking adapter); or, for a large-scale non-volatilestorage within the computing device 4100 (e.g., hard disk drive). Userinput devices, including alphanumeric and other keys, may be used tocommunicate information and command selections to graphics processor4104. Another type of user input device is cursor control, such as amouse, a trackball, a touchscreen, a touchpad, or cursor direction keysto communicate direction information and command selections to GPU andto control cursor movement on the display device. Camera and microphonearrays of the computing device 4100 may be employed to observe gestures,record audio and video and to receive and transmit visual and audiocommands.

I/O sources 4110 configured as network interfaces can provide access toa network, such as a LAN, a wide area network (WAN), a metropolitan areanetwork (MAN), a personal area network (PAN), Bluetooth, a cloudnetwork, a cellular or mobile network (e.g., 3rd Generation (3G), 4thGeneration (4G), etc.), an intranet, the Internet, etc. Networkinterface(s) may include, for example, a wireless network interfacehaving one or more antenna(e). Network interface(s) may also include,for example, a wired network interface to communicate with remotedevices via network cable, which may be, for example, an Ethernet cable,a coaxial cable, a fiber optic cable, a serial cable, or a parallelcable.

Network interface(s) may provide access to a LAN, for example, byconforming to IEEE 802.11 standards, and/or the wireless networkinterface may provide access to a personal area network, for example, byconforming to Bluetooth standards. Other wireless network interfacesand/or protocols, including previous and subsequent versions of thestandards, may also be supported. In addition to, or instead of,communication via the wireless LAN standards, network interface(s) mayprovide wireless communication using, for example, Time Division,Multiple Access (TDMA) protocols, Global Systems for MobileCommunications (GSM) protocols, Code Division, Multiple Access (CDMA)protocols, and/or any other type of wireless communications protocols.

It is to be appreciated that a lesser or more equipped system than theexample described above may be preferred for certain implementations.Therefore, the configuration of the computing device 4100 may vary fromimplementation to implementation depending upon numerous factors, suchas price constraints, performance requirements, technologicalimprovements, or other circumstances. Examples include (withoutlimitation) a mobile device, a personal digital assistant, a mobilecomputing device, a smartphone, a cellular telephone, a handset, aone-way pager, a two-way pager, a messaging device, a computer, apersonal computer (PC), a desktop computer, a laptop computer, anotebook computer, a handheld computer, a tablet computer, a server, aserver array or server farm, a web server, a network server, an Internetserver, a work station, a mini-computer, a main frame computer, asupercomputer, a network appliance, a web appliance, a distributedcomputing system, multiprocessor systems, processor-based systems,consumer electronics, programmable consumer electronics, television,digital television, set top box, wireless access point, base station,subscriber station, mobile subscriber center, radio network controller,router, hub, gateway, bridge, switch, machine, or combinations thereof.

Embodiments may be implemented as any one, or a combination of: one ormore microchips or integrated circuits interconnected using aparent-board, hardwired logic, software stored by a memory device andexecuted by a microprocessor, firmware, an application specificintegrated circuit (ASIC), and/or a field programmable gate array(FPGA). The term “logic” may include, by way of example, software orhardware and/or combinations of software and hardware.

Embodiments may be provided, for example, as a computer program productwhich may include one or more machine-readable media having storedthereon machine-executable instructions that, when executed by one ormore machines such as a computer, network of computers, or otherelectronic devices, may result in the one or more machines carrying outoperations in accordance with embodiments described herein. Amachine-readable medium may include, but is not limited to, floppydiskettes, optical disks, CD-ROMs (Compact Disc-Read Only Memories), andmagneto-optical disks, ROMs, RAMs, EPROMs (Erasable Programmable ReadOnly Memories), EEPROMs (Electrically Erasable Programmable Read OnlyMemories), magnetic or optical cards, flash memory, or other type ofnon-transitory machine-readable media suitable for storingmachine-executable instructions.

Moreover, embodiments may be downloaded as a computer program product,wherein the program may be transferred from a remote computer (e.g., aserver) to a requesting computer (e.g., a client) by way of one or moredata signals embodied in and/or modulated by a carrier wave or otherpropagation medium via a communication link (e.g., a modem and/ornetwork connection).

Embodiments described herein provide for an instruction and associatedlogic to enable GPGPU program code to access special purpose hardwarelogic to accelerate dot product operations. The following clauses and/orexamples pertain to specific embodiments or examples thereof. Specificsin the examples may be used anywhere in one or more embodiments. Thevarious features of the different embodiments or examples may bevariously combined with some features included and others excluded tosuit a variety of different applications. Examples may include subjectmatter such as a method, means for performing acts of the method, atleast one machine-readable medium including instructions that, whenperformed by a machine cause the machine to perform acts of the method,or of an apparatus or system according to embodiments and examplesdescribed herein. Various components can be a means for performing theoperations or functions described.

One embodiment provides for a computing device comprising one or moreprocessors including a graphics processor. The graphics processorincludes a processing resource including a tensor accelerator. Thetensor accelerator is configurable to perform numerical operations totrain a neural network model and generate a first matrix of weightsassociated with the neural network model. The graphics processoradditionally includes a weight transformer to apply a numericaltransform to the first matrix of weights to generate a set oftransformed weights and a transform type. The transform type identifiesthe numerical transform applied to the first matrix of weights. Thefirst matrix of weights is a sparse matrix and the transformed weightscompress to a higher compression ratio than the first matrix of weights.

In various embodiments the weight transformer is a fixed-functionhardware unit of the graphics processor or is implemented viaprogrammable hardware of the graphics processor. The weight transformerincludes a transform selector and a transform tester. The transformtester is configurable to apply a first numerical transform to at leasta portion of the first matrix of weights to generate first testtransform data, apply a second numerical transform to at least a portionof the first matrix of weights to generate second test transform data,determine compressibility metrics based on analysis of the first testtransform data and the second test transform data, and send arecommended transform to the transform selector. The specific number ofnumerical transforms that may be tested is not limited. Test transformscan be performed in parallel. The transform selector can then select anumerical transform to apply to the first matrix of weights based on therecommended transform. A numerical transform other than the recommendedtransform may also be selected. The numerical transform can be selectedfrom a set of numerical transforms including a discrete cosinetransform, a discrete sine transform, a bit-flip transform, and abit-rotate transform. In a further embodiment, the graphics processorfurther comprises an inverse weight transformer to apply a numericalinverse transform to the transformed weights to generate a second matrixof weights. The numerical inverse transform to perform is identified byan inverse transform selector of the inverse weight transformed via thetransform type associated with the set of transformed weights.

One embodiment provides a method comprising, on a graphics processorincluding a tensor accelerator, loading matrix data and metadataassociated with the matrix data into the tensor accelerator, wherein themetadata indicates a numerical transform applied to the matrix data,performing, by the tensor accelerator, a numerical inverse transform onthe matrix data, the numerical inverse transform indicated by themetadata associated with the matrix data, performing one or more computeoperations within the tensor accelerator after performing the numericalinverse transform, and writing output of the one or more computeoperations to a memory of the graphics processor.

In a further embodiment, the method further comprises decompressing ordecoding the matrix data within the tensor accelerator before performingthe numerical inverse transform on the matrix data and compressing orencoding the output within the tensor accelerator after performing thenumerical transform on the matrix data. In one embodiment, writingoutput of the one or more compute operations to the memory of thegraphics processor includes writing the output to a cache memory of thegraphics processor and/or writing the output to a main memory of thegraphics processor.

A numerical transform can also be applied to the output of the one ormore compute operations before writing the output to the memory of thegraphics processor. The numerical transform can be a specified numericaltransform. Applying the numerical transform can also include generating,by the tensor accelerator, transform test metrics for multiple numericaltransforms, selecting a numerical transform based on the transform testmetrics, and applying the selected numerical transform to the output.The selected numerical transform can be selected from a set of numericaltransforms including a discrete cosine transform, a discrete sinetransform, a bit-flip transform, and a bit-rotate transform.

One embodiment provides a graphics processor comprising a processingresource including a tensor accelerator, wherein the tensor acceleratoris to perform numerical operations to train a neural network model andgenerate a first matrix of weights associated with the neural networkmodel, a weight transformer to apply a numerical transform to the firstmatrix of weights to generate a set of transformed weights and atransform type, wherein the transform type identifies the numericaltransform applied to the first matrix of weights, wherein the firstmatrix of weights is a sparse matrix and the transformed weightscompress to a higher compression ratio than the first matrix of weights,and an inverse weight transformer to apply a numerical inverse transformto the transformed weights to generate a second matrix of weights,wherein the numerical inverse transform to perform is identified via thetransform type associated with the set of transformed weights.

In a further embodiment, the weight transformer includes a transformselector and a transform tester, the transform tester to apply a firstnumerical transform to at least a portion of the first matrix of weightsto generate first test transform data, apply a second numericaltransform to at least a portion of the first matrix of weights togenerate second test transform data, determine compressibility metricsbased on analysis of the first test transform data and the second testtransform data, and send a recommended transform to the transformselector, the transform selector to select a numerical transform toapply to the first matrix of weights based on the recommended transform.The numerical transform is selected from a set of numerical transformsincluding a discrete cosine transform, a discrete sine transform, abit-flip transform, and a bit-rotate transform.

The foregoing description and drawings are to be regarded in anillustrative rather than a restrictive sense. Persons skilled in the artwill understand that various modifications and changes may be made tothe embodiments described herein without departing from the broaderspirit and scope of the features set forth in the appended claims.

What is claimed is:
 1. A computing device comprising: one or moreprocessors including a graphics processor, the graphics processorincluding: a processing resource including a tensor accelerator, whereinthe tensor accelerator is to perform numerical operations to train aneural network model and generate a first matrix of weights associatedwith the neural network model; and a weight transformer to apply anumerical transform to the first matrix of weights to generate a set oftransformed weights and a transform type, wherein the transform typeidentifies the numerical transform applied to the first matrix ofweights, wherein the first matrix of weights is a sparse matrix and thetransformed weights compress to a higher compression ratio than thefirst matrix of weights.
 2. The computing device as in claim 1, whereinthe weight transformer is a fixed-function hardware unit of the graphicsprocessor.
 3. The computing device as in claim 1, wherein the weighttransformer is implemented via programmable hardware of the graphicsprocessor.
 4. The computing device as in claim 1, wherein the weighttransformer includes a transform selector and a transform tester, thetransform tester to: apply a first numerical transform to at least aportion of the first matrix of weights to generate first test transformdata; apply a second numerical transform to at least a portion of thefirst matrix of weights to generate second test transform data;determine compressibility metrics based on analysis of the first testtransform data and the second test transform data; and send arecommended transform to the transform selector.
 5. The computing deviceas in claim 4, the transform selector further to select a numericaltransform to apply to the first matrix of weights based on therecommended transform.
 6. The computing device as in claim 5, whereinthe numerical transform is selected from a set of numerical transformsincluding a discrete cosine transform, a discrete sine transform, abit-flip transform, and a bit-rotate transform.
 7. The computing deviceas in claim 1, the graphics processor further comprising: an inverseweight transformer to apply a numerical inverse transform to the set oftransformed weights to generate a second matrix of weights, wherein thenumerical inverse transform to perform is identified via the transformtype associated with the set of transformed weights.
 8. The computingdevice as in claim 1, wherein the tensor accelerator includes a systolicarray of processing elements.
 9. A method comprising: on a graphicsprocessor including a tensor accelerator: loading matrix data andmetadata associated with the matrix data into the tensor accelerator,wherein the metadata indicates a numerical transform applied to thematrix data; performing, by the tensor accelerator, a numerical inversetransform on the matrix data, the numerical inverse transform indicatedby the metadata associated with the matrix data; performing one or morecompute operations within the tensor accelerator after performing thenumerical inverse transform; and writing output of the one or morecompute operations to a memory of the graphics processor.
 10. The methodas in claim 9, additionally comprising decompressing or decoding thematrix data within the tensor accelerator before performing thenumerical inverse transform on the matrix data.
 11. The method as inclaim 10, additionally comprising compressing or encoding the outputwithin the tensor accelerator after performing the numerical transformon the matrix data.
 12. The method as in claim 9, wherein writing outputof the one or more compute operations to the memory of the graphicsprocessor includes writing the output to a cache memory of the graphicsprocessor.
 13. The method as in claim 9, wherein writing output of theone or more compute operations to the memory of the graphics processorincludes writing the output to a main memory of the graphics processor.14. The method as in claim 9, further comprising applying a numericaltransform to the output of the one or more compute operations beforewriting the output to the memory of the graphics processor.
 15. Themethod as in claim 14, wherein applying the numerical transform to theoutput of the one or more compute operations comprises applying aspecified numerical transform to the output.
 16. The method as in claim14, wherein applying the numerical transform to the output of the one ormore compute operations comprises generating, by the tensor accelerator,transform test metrics for multiple numerical transforms, selecting anumerical transform based on the transform test metrics, and applyingthe selected numerical transform to the output.
 17. The method as inclaim 16, wherein the selected numerical transform is selected from aset of numerical transforms including a discrete cosine transform, adiscrete sine transform, a bit-flip transform, and a bit-rotatetransform.
 18. A graphics processor comprising: a processing resourceincluding a tensor accelerator, wherein the tensor accelerator is toperform numerical operations to train a neural network model andgenerate a first matrix of weights associated with the neural networkmodel; a weight transformer to apply a numerical transform to the firstmatrix of weights to generate a set of transformed weights and atransform type, wherein the transform type identifies the numericaltransform applied to the first matrix of weights, wherein the firstmatrix of weights is a sparse matrix and the transformed weightscompress to a higher compression ratio than the first matrix of weights;and an inverse weight transformer to apply a numerical inverse transformto the transformed weights to generate a second matrix of weights,wherein the numerical inverse transform to perform is identified via thetransform type associated with the set of transformed weights.
 19. Thegraphics processor as in claim 18, wherein the weight transformerincludes a transform selector and a transform tester, the transformtester to: apply a first numerical transform to at least a portion ofthe first matrix of weights to generate first test transform data; applya second numerical transform to at least a portion of the first matrixof weights to generate second test transform data; determinecompressibility metrics based on analysis of the first test transformdata and the second test transform data; and send a recommendedtransform to the transform selector, the transform selector to select anumerical transform to apply to the first matrix of weights based on therecommended transform.
 20. The graphics processor as in claim 19,wherein the numerical transform is selected from a set of numericaltransforms including a discrete cosine transform, a discrete sinetransform, a bit-flip transform, and a bit-rotate transform.